Merge pull request #429 from andrewhsu/v

[17.12] bump version to 17.12.1-ce-rc2

CHANGELOG.md

@@ -1,155 +1,151 @@
-# Changelog 
-For more information on the list of deprecated flags and APIs please have a look at
-https://docs.docker.com/engine/deprecated/ where you can find the target removal dates 
+# Changelog
 
-## 18.03.1-ce (2018-04-DD)
+Items starting with `DEPRECATE` are important deprecation notices. For more
+information on the list of deprecated flags and APIs please have a look at
+https://docs.docker.com/engine/deprecated/ where target removal dates can also
+be found.
+
+**IMPORTANT**: You must stop all containers and plugins **BEFORE** upgrading to Docker CE 17.12.
+See related PR: [moby/moby#35812](https://github.com/moby/moby/pull/35812) 
+
+## 17.12.1-ce (2018-02-DD)
 
 ### Client
+- Fix `node-generic-resource` typo [moby/moby#35970](https://github.com/moby/moby/pull/35970) and [moby/moby#36125](https://github.com/moby/moby/pull/36125)
+* Return errors from daemon on stack deploy configs create/update [docker/cli#757](https://github.com/docker/cli/pull/757)
 
-- Fix error with merge compose file with networks [docker/cli#983](https://github.com/docker/cli/pull/983)
-* Fix docker stack deploy re-deploying services after the service was updated with `--force` [docker/cli#963](https://github.com/docker/cli/pull/963)
-* Fix docker version output alignment [docker/cli#965](https://github.com/docker/cli/pull/965)
-
-### Runtime
-
-- Fix AppArmor profiles not being applied to `docker exec` processes [moby/moby#36466](https://github.com/moby/moby/pull/36466)
-- Don't sort plugin mount slice [moby/moby#36711](https://github.com/moby/moby/pull/36711)
-- Daemon/cluster: handle partial attachment entries during configure [moby/moby#36769](https://github.com/moby/moby/pull/36769)
-* Bump Golang to 1.9.5 [moby/moby#36779](https://github.com/moby/moby/pull/36779) [docker/cli#986](https://github.com/docker/cli/pull/986)
-- Daemon/stats: more resilient cpu sampling [moby/moby#36519](https://github.com/moby/moby/pull/36519)
-* Containerd: update to 1.0.3 release [moby/moby#36749](https://github.com/moby/moby/pull/36749)
-- Fix Windows layer leak when write fails [moby/moby#36728](https://github.com/moby/moby/pull/36728)
-* Don't make container mount unbindable [moby/moby#36768](https://github.com/moby/moby/pull/36768)
-- Fix Daemon panics on container export after a daemon restart [moby/moby/36586](https://github.com/moby/moby/pull/36586)
-- Fix digest cache being removed on autherrors [moby/moby#36509](https://github.com/moby/moby/pull/36509)
-- Make sure plugin container is removed on failure [moby/moby#36715](https://github.com/moby/moby/pull/36715)
-- Copy: avoid using all system memory with authz plugins [moby/moby#36595](https://github.com/moby/moby/pull/36595)
-- Relax some libcontainerd client locking [moby/moby#36848](https://github.com/moby/moby/pull/36848)
-
-### Swarm Mode
-
-* Increase raft Election tick to 10 times Heartbeat tick [moby/moby#36672](https://github.com/moby/moby/pull/36672)
+### Logging
+- awslogs: fix batch size calculation for large logs [moby/moby#35726](https://github.com/moby/moby/pull/35726)
+* Support a proxy in splunk log driver [moby/moby#36220](https://github.com/moby/moby/pull/36220)
 
 ### Networking
+- Fix ingress network when upgrading from 17.09 to 17.12 [moby/moby#36003](https://github.com/moby/moby/pull/36003)
+* Add verbose info to partial overlay ID [moby/moby#35989](https://github.com/moby/moby/pull/35989)
+- Fix IPv6 networking being deconfigured if live-restore is being enabled [docker/libnetwork#2043](https://github.com/docker/libnetwork/pull/2043)
+- Fix watchMiss thread context [docker/libnetwork#2051](https://github.com/docker/libnetwork/pull/2051)
 
-* Gracefully remove LB endpoints from services [docker/libnetwork#2112](https://github.com/docker/libnetwork/pull/2112)
-* Retry other external DNS servers on ServFail [docker/libnetwork#2121](https://github.com/docker/libnetwork/pull/2121)
-* Improve scalabiltiy of bridge network isolation rules [docker/libnetwork#2117](https://github.com/docker/libnetwork/pull/2117)
-* Allow for larger preset property values, do not override [docker/libnetwork#2124](https://github.com/docker/libnetwork/pull/2124)
-* Prevent panics on concurrent reads/writes when calling `changeNodeState` [docker/libnetwork#2136](https://github.com/docker/libnetwork/pull/2136)
+### Packaging
+- Set TasksMax in docker.service [docker/docker-ce-packaging#78](https://github.com/docker/docker-ce-packaging/pull/78)
 
-## 18.03.0-ce (2018-03-21)
+### Runtime
+* Bump Golang to 1.9.4
+* Bump containerd to 1.0.1
+- Fix dockerd not being able to reconnect to containerd when it is restarted [moby/moby#36173](https://github.com/moby/moby/pull/36173)
+- Fix containerd events from being processed twice [moby/moby#35891](https://github.com/moby/moby/issues/35891)
+- Fix vfs graph driver failure to initialize because of failure to setup fs quota [moby/moby#35827](https://github.com/moby/moby/pull/35827)
+- Fix regression of health check not using container's working directory [moby/moby#35845](https://github.com/moby/moby/pull/35845)
+- Honor `DOCKER_RAMDISK` with containerd 1.0 [moby/moby#35957](https://github.com/moby/moby/pull/35957)
+- Update runc to fix hang during start and exec [moby/moby#36097](https://github.com/moby/moby/pull/36097) 
+- Windows: Vendor of Microsoft/hcsshim @v.0.6.8 partial fix for import layer failing [moby/moby#35924](https://github.com/moby/moby/pull/35924)
+* Do not make graphdriver homes private mounts [moby/moby#36047](https://github.com/moby/moby/pull/36047)
+* Use rslave propogation for mounts from daemon root [moby/moby#36055](https://github.com/moby/moby/pull/36055)
+* Set daemon root to use shared mount propagation [moby/moby#36096](https://github.com/moby/moby/pull/36096)
+* Validate that mounted paths exist when container is started, not just during creation  [moby/moby#35833](https://github.com/moby/moby/pull/35833)
+* Add `REMOVE` and `ORPHANED` to TaskState [moby/moby#36146](https://github.com/moby/moby/pull/36146)
+- Fix issue where network inspect does not show Created time for networks in swarm scope [moby/moby#36095](https://github.com/moby/moby/pull/36095)
+* Nullify container read write layer upon release [moby/moby#36130](https://github.com/moby/moby/pull/36160) and [moby/moby#36343](https://github.com/moby/moby/pull/36242)
+
+### Swarm
+* Remove watchMiss from swarm mode [docker/libnetwork#2047](https://github.com/docker/libnetwork/pull/2047) 
+
+## 17.12.0-ce (2017-12-27)
+
+## Known Issues
+* AWS logs batch size calculation [moby/moby#35726](https://github.com/moby/moby/pull/35726)
+* Health check no longer uses the container's working directory [moby/moby#35843](https://github.com/moby/moby/issues/35843) 
+* Errors not returned from client in stack deploy configs [moby/moby#757](https://github.com/docker/cli/pull/757)
+* Daemon aborts when project quota fails [moby/moby#35827](https://github.com/moby/moby/pull/35827) 
+* Docker cannot use memory limit when using systemd options [moby/moby#35123](https://github.com/moby/moby/issues/35123)
 
 ### Builder
 
-* Switch to -buildmode=pie [moby/moby#34369](https://github.com/moby/moby/pull/34369)
-* Allow Dockerfile to be outside of build-context [docker/cli#886](https://github.com/docker/cli/pull/886) 
-* Builder: fix wrong cache hits building from tars [moby/moby#36329](https://github.com/moby/moby/pull/36329)
-- Fixes files leaking to other images in a multi-stage build [moby/moby#36338](https://github.com/moby/moby/pull/36338)
+- Fix build cache hash for broken symlink [moby/moby#34271](https://github.com/moby/moby/pull/34271)
+- Fix long stream sync [moby/moby#35404](https://github.com/moby/moby/pull/35404)
+- Fix dockerfile parser failing silently on long tokens [moby/moby#35429](https://github.com/moby/moby/pull/35429)
 
 ### Client
 
-* Simplify the marshaling of compose types.Config [docker/cli#895](https://github.com/docker/cli/pull/895)
-+ Add support for multiple composefile when deploying [docker/cli#569](https://github.com/docker/cli/pull/569)
-- Fix broken Kubernetes stack flags [docker/cli#831](https://github.com/docker/cli/pull/831)
-- Fix stack marshaling for Kubernetes [docker/cli#890](https://github.com/docker/cli/pull/890)
-- Fix and simplify bash completion for service env, mounts and labels [docker/cli#682](https://github.com/docker/cli/pull/682)
-- Fix `before` and `since` filter for `docker ps` [moby/moby#35938](https://github.com/moby/moby/pull/35938)
-- Fix `--label-file` weird behavior [docker/cli#838](https://github.com/docker/cli/pull/838)
-- Fix compilation of defaultCredentialStore() on unsupported platforms [docker/cli#872](https://github.com/docker/cli/pull/872)
-* Improve and fix bash completion for images [docker/cli#717](https://github.com/docker/cli/pull/717)
-+ Added check for empty source in bind mount [docker/cli#824](https://github.com/docker/cli/pull/824)
-- Fix TLS from environment variables in client [moby/moby#36270](https://github.com/moby/moby/pull/36270)
-* docker build now runs faster when registry-specific credential helper(s) are configured [docker/cli#840](https://github.com/docker/cli/pull/840)
-* Update event filter zsh completion with `disable`, `enable`, `install` and `remove` [docker/cli#372](https://github.com/docker/cli/pull/372)
-* Produce errors when empty ids are passed into inspect calls [moby/moby#36144](https://github.com/moby/moby/pull/36144)
-* Marshall version for the k8s controller [docker/cli#891](https://github.com/docker/cli/pull/891)
-* Set a non-zero timeout for HTTP client communication with plugin backend [docker/cli#883](https://github.com/docker/cli/pull/883)
-+ Add DOCKER_TLS environment variable for --tls option [docker/cli#863](https://github.com/docker/cli/pull/863)
-+ Add --template-driver option for secrets/configs [docker/cli#896](https://github.com/docker/cli/pull/896)
-+ Move `docker trust` commands out of experimental [docker/cli#934](https://github.com/docker/cli/pull/934) [docker/cli#935](https://github.com/docker/cli/pull/935) [docker/cli#944](https://github.com/docker/cli/pull/944)
+* Remove secret/config duplication in cli/compose [docker/cli#671](https://github.com/docker/cli/pull/671)
+* Add `--local` flag to `docker trust sign` [docker/cli#575](https://github.com/docker/cli/pull/575)
+* Add `docker trust inspect` [docker/cli#694](https://github.com/docker/cli/pull/694)
++ Add `name` field to secrets and configs to allow interpolation in Compose files [docker/cli#668](https://github.com/docker/cli/pull/668)
++ Add `--isolation` for setting swarm service isolation mode [docker/cli#426](https://github.com/docker/cli/pull/426)
+* Remove deprecated "daemon" subcommand [docker/cli#689](https://github.com/docker/cli/pull/689)
+- Fix behaviour of `rmi -f` with unexpected errors [docker/cli#654](https://github.com/docker/cli/pull/654)
+* Integrated Generic resource in service create [docker/cli#429](https://github.com/docker/cli/pull/429)
+- Fix external networks in stacks [docker/cli#743](https://github.com/docker/cli/pull/743)
+* Remove support for referencing images by image shortid [docker/cli#753](https://github.com/docker/cli/pull/753) and [moby/moby#35790](https://github.com/moby/moby/pull/35790)
+* Use commit-sha instead of tag for containerd [moby/moby#35770](https://github.com/moby/moby/pull/35770)
+
+### Documentation
+
+* Update API version history for 1.35 [moby/moby#35724](https://github.com/moby/moby/pull/35724)
 
 ### Logging
 
-* AWS logs - don't add new lines to maximum sized events [moby/moby#36078](https://github.com/moby/moby/pull/36078)
-* Move log validator logic after plugins are loaded [moby/moby#36306](https://github.com/moby/moby/pull/36306)
-* Support a proxy in Splunk log driver [moby/moby#36220](https://github.com/moby/moby/pull/36220)
-- Fix log tail with empty logs [moby/moby#36305](https://github.com/moby/moby/pull/36305)
+* Logentries driver line-only=true []byte output fix [moby/moby#35612](https://github.com/moby/moby/pull/35612)
+* Logentries line-only logopt fix to maintain backwards compatibility [moby/moby#35628](https://github.com/moby/moby/pull/35628)
++ Add `--until` flag for docker logs [moby/moby#32914](https://github.com/moby/moby/pull/32914)
++ Add gelf log driver plugin to Windows build [moby/moby#35073](https://github.com/moby/moby/pull/35073)
+* Set timeout on Splunk batch send [moby/moby#35496](https://github.com/moby/moby/pull/35496)
+* Update Graylog2/go-gelf [moby/moby#35765](https://github.com/moby/moby/pull/35765)
 
 ### Networking
 
-* Libnetwork revendoring [moby/moby#36137](https://github.com/moby/moby/pull/36137)
-- Fix for deadlock on exit with Memberlist revendor [docker/libnetwork#2040](https://github.com/docker/libnetwork/pull/2040)
-* Fix user specified ndots option [docker/libnetwork#2065](https://github.com/docker/libnetwork/pull/2065) 
-- Fix to use ContainerID for Windows instead of SandboxID [docker/libnetwork#2010](https://github.com/docker/libnetwork/pull/2010)
-* Verify NetworkingConfig to make sure EndpointSettings is not nil [moby/moby#36077](https://github.com/moby/moby/pull/36077)
-- Fix `DockerNetworkInternalMode` issue [moby/moby#36298](https://github.com/moby/moby/pull/36298)
-- Fix race in attachable network attachment [moby/moby#36191](https://github.com/moby/moby/pull/36191)
-- Fix timeout issue of `InspectNetwork` on AArch64 [moby/moby#36257](https://github.com/moby/moby/pull/36257)
-* Verbose info is missing for partial overlay ID [moby/moby#35989](https://github.com/moby/moby/pull/35989)
-* Update `FindNetwork` to address network name duplications [moby/moby#30897](https://github.com/moby/moby/pull/30897)
-* Disallow attaching ingress network [docker/swarmkit#2523](https://github.com/docker/swarmkit/pull/2523)
-- Prevent implicit removal of the ingress network [moby/moby#36538](https://github.com/moby/moby/pull/36538)
-- Fix stale HNS endpoints on Windows [moby/moby#36603](https://github.com/moby/moby/pull/36603)
-- IPAM fixes for duplicate IP addresses [docker/libnetwork#2104](https://github.com/docker/libnetwork/pull/2104) [docker/libnetwork#2105](https://github.com/docker/libnetwork/pull/2105)
+* Move load balancer sandbox creation/deletion into libnetwork [moby/moby#35422](https://github.com/moby/moby/pull/35422)
+* Only chown network files within container metadata [moby/moby#34224](https://github.com/moby/moby/pull/34224)
+* Restore error type in FindNetwork [moby/moby#35634](https://github.com/moby/moby/pull/35634)
+- Fix consumes MIME type for NetworkConnect [moby/moby#35542](https://github.com/moby/moby/pull/35542)
++ Added support for persisting Windows network driver specific options [moby/moby#35563](https://github.com/moby/moby/pull/35563)
+- Fix timeout on netlink sockets and watchmiss leak [moby/moby#35677](https://github.com/moby/moby/pull/35677)
++ New daemon config for networking diagnosis [moby/moby#35677](https://github.com/moby/moby/pull/35677)
+- Clean up node management logic [docker/libnetwork#2036](https://github.com/docker/libnetwork/pull/2036)
+- Allocate VIPs when endpoints are restored [docker/swarmkit#2474](https://github.com/docker/swarmkit/pull/2474)
 
 ### Runtime
 
-* Enable HotAdd for Windows [moby/moby#35414](https://github.com/moby/moby/pull/35414)
-* LCOW: Graphdriver fix deadlock in hotRemoveVHDs [moby/moby#36114](https://github.com/moby/moby/pull/36114)
-* LCOW: Regular mount if only one layer [moby/moby#36052](https://github.com/moby/moby/pull/36052)
-* Remove interim env var LCOW_API_PLATFORM_IF_OMITTED [moby/moby#36269](https://github.com/moby/moby/pull/36269)
-* Revendor Microsoft/opengcs @ v0.3.6 [moby/moby#36108](https://github.com/moby/moby/pull/36108)
-- Fix issue of ExitCode and PID not show up in Task.Status.ContainerStatus [moby/moby#36150](https://github.com/moby/moby/pull/36150)
-- Fix issue with plugin scanner going too deep [moby/moby#36119](https://github.com/moby/moby/pull/36119)
-* Do not make graphdriver homes private mounts [moby/moby#36047](https://github.com/moby/moby/pull/36047)
-* Do not recursive unmount on cleanup of zfs/btrfs [moby/moby#36237](https://github.com/moby/moby/pull/36237)
-* Don't restore image if layer does not exist [moby/moby#36304](https://github.com/moby/moby/pull/36304)
-* Adjust minimum API version for templated configs/secrets [moby/moby#36366](https://github.com/moby/moby/pull/36366)
-* Bump containerd to 1.0.2 (cfd04396dc68220d1cecbe686a6cc3aa5ce3667c) [moby/moby#36308](https://github.com/moby/moby/pull/36308)
-* Bump Golang to 1.9.4 [moby/moby#36243](https://github.com/moby/moby/pull/36243)
-* Ensure daemon root is unmounted on shutdown [moby/moby#36107](https://github.com/moby/moby/pull/36107)
-- Fix container cleanup on daemon restart [moby/moby#36249](https://github.com/moby/moby/pull/36249)
-* Support SCTP port mapping (bump up API to v1.37) [moby/moby#33922](https://github.com/moby/moby/pull/33922)
-* Support SCTP port mapping [docker/cli#278](https://github.com/docker/cli/pull/278)
-- Fix Volumes property definition in ContainerConfig [moby/moby#35946](https://github.com/moby/moby/pull/35946)
-* Bump moby and dependencies [docker/cli#829](https://github.com/docker/cli/pull/829)
-* C.RWLayer: check for nil before use [moby/moby#36242](https://github.com/moby/moby/pull/36242)
-+ Add `REMOVE` and `ORPHANED` to TaskState [moby/moby#36146](https://github.com/moby/moby/pull/36146)
-- Fixed error detection using `IsErrNotFound` and `IsErrNotImplemented` for `ContainerStatPath`, `CopyFromContainer`, and `CopyToContainer` methods [moby/moby#35979](https://github.com/moby/moby/pull/35979)
-+ Add an integration/internal/container helper package [moby/moby#36266](https://github.com/moby/moby/pull/36266)
-+ Add canonical import path [moby/moby#36194](https://github.com/moby/moby/pull/36194)
-+ Add/use container.Exec() to integration [moby/moby#36326](https://github.com/moby/moby/pull/36326)
-- Fix "--node-generic-resource" singular/plural [moby/moby#36125](https://github.com/moby/moby/pull/36125)
-* Daemon.cleanupContainer: nullify container RWLayer upon release [moby/moby#36160](https://github.com/moby/moby/pull/36160)
-* Daemon: passdown the `--oom-kill-disable` option to containerd [moby/moby#36201](https://github.com/moby/moby/pull/36201)
-* Display a warn message when there is binding ports and net mode is host [moby/moby#35510](https://github.com/moby/moby/pull/35510)
-* Refresh containerd remotes on containerd restarted [moby/moby#36173](https://github.com/moby/moby/pull/36173)
-* Set daemon root to use shared propagation [moby/moby#36096](https://github.com/moby/moby/pull/36096)
-* Optimizations for recursive unmount [moby/moby#34379](https://github.com/moby/moby/pull/34379)
-* Perform plugin mounts in the runtime [moby/moby#35829](https://github.com/moby/moby/pull/35829)
-* Graphdriver: Fix RefCounter memory leak [moby/moby#36256](https://github.com/moby/moby/pull/36256)
-* Use continuity fs package for volume copy [moby/moby#36290](https://github.com/moby/moby/pull/36290)
-* Use proc/exe for reexec [moby/moby#36124](https://github.com/moby/moby/pull/36124)
-+ Add API support for templated secrets and configs [moby/moby#33702](https://github.com/moby/moby/pull/33702) and [moby/moby#36366](https://github.com/moby/moby/pull/36366)
-* Use rslave propagation for mounts from daemon root [moby/moby#36055](https://github.com/moby/moby/pull/36055)
-+ Add /proc/keys to masked paths [moby/moby#36368](https://github.com/moby/moby/pull/36368)
-* Bump Runc to 1.0.0-rc5 [moby/moby#36449](https://github.com/moby/moby/pull/36449)
-- Fixes `runc exec` on big-endian architectures [moby/moby#36449](https://github.com/moby/moby/pull/36449)
-* Use chroot when mount namespaces aren't provided [moby/moby#36449](https://github.com/moby/moby/pull/36449)
-- Fix systemd slice expansion so that it could be consumed by cAdvisor [moby/moby#36449](https://github.com/moby/moby/pull/36449)
-- Fix devices mounted with wrong uid/gid [moby/moby#36449](https://github.com/moby/moby/pull/36449)
-- Fix read-only containers with IPC private mounts `/dev/shm` read-only [moby/moby#36526](https://github.com/moby/moby/pull/36526)
+* Update to containerd v1.0.0 [moby/moby#35707](https://github.com/moby/moby/pull/35707)
+* Have VFS graphdriver use accelerated in-kernel copy [moby/moby#35537](https://github.com/moby/moby/pull/35537)
+* Introduce `workingdir` option for docker exec [moby/moby#35661](https://github.com/moby/moby/pull/35661)
+* Bump Go to 1.9.2 [moby/moby#33892](https://github.com/moby/moby/pull/33892) [docker/cli#716](https://github.com/docker/cli/pull/716)
+* `/dev` should not be readonly with `--readonly` flag [moby/moby#35344](https://github.com/moby/moby/pull/35344)
++ Add custom build-time Graphdrivers priority list [moby/moby#35522](https://github.com/moby/moby/pull/35522)
+* LCOW: CLI changes to add platform flag - pull, run, create and build [docker/cli#474](https://github.com/docker/cli/pull/474)
+* Fix width/height on Windoes for `docker exec` [moby/moby#35631](https://github.com/moby/moby/pull/35631)
+* Detect overlay2 support on pre-4.0 kernels [moby/moby#35527](https://github.com/moby/moby/pull/35527)
+* Devicemapper: remove container rootfs mountPath after umount [moby/moby#34573](https://github.com/moby/moby/pull/34573)
+* Disallow overlay/overlay2 on top of NFS [moby/moby#35483](https://github.com/moby/moby/pull/35483)
+- Fix potential panic during plugin set. [moby/moby#35632](https://github.com/moby/moby/pull/35632)
+- Fix some issues with locking on the container [moby/moby#35501](https://github.com/moby/moby/pull/35501)
+- Fixup some issues with plugin refcounting [moby/moby#35265](https://github.com/moby/moby/pull/35265)
++ Add missing lock in ProcessEvent [moby/moby#35516](https://github.com/moby/moby/pull/35516)
++ Add vfs quota support [moby/moby#35231](https://github.com/moby/moby/pull/35231)
+* Skip empty directories on prior graphdriver detection [moby/moby#35528](https://github.com/moby/moby/pull/35528)
+* Skip xfs quota tests when running in user namespace [moby/moby#35526](https://github.com/moby/moby/pull/35526)
++ Added SubSecondPrecision to config option. [moby/moby#35529](https://github.com/moby/moby/pull/35529)
+* Update fsnotify to fix deadlock in removing watch [moby/moby#35453](https://github.com/moby/moby/pull/35453)
+- Fix "duplicate mount point" when `--tmpfs /dev/shm` is used [moby/moby#35467](https://github.com/moby/moby/pull/35467)
+- Fix honoring tmpfs-size for user `/dev/shm` mount [moby/moby#35316](https://github.com/moby/moby/pull/35316)
+- Fix EBUSY errors under overlayfs and v4.13+ kernels [moby/moby#34948](https://github.com/moby/moby/pull/34948)
+* Container: protect health monitor channel [moby/moby#35482](https://github.com/moby/moby/pull/35482)
+* Container: protect the health status with mutex [moby/moby#35517](https://github.com/moby/moby/pull/35517)
+* Container: update real-time resources [moby/moby#33731](https://github.com/moby/moby/pull/33731)
+* Create labels when volume exists only remotely [moby/moby#34896](https://github.com/moby/moby/pull/34896)
+- Fix leaking container/exec state [moby/moby#35484](https://github.com/moby/moby/pull/35484)
+* Disallow using legacy (v1) registries [moby/moby#35751](https://github.com/moby/moby/pull/35751) and [docker/cli#747](https://github.com/docker/cli/pull/747)
+- Windows: Fix case insensitive filename matching against builder cache [moby/moby#35793](https://github.com/moby/moby/pull/35793)
+- Fix race conditions around process handling and error checks [moby/moby#35809](https://github.com/moby/moby/pull/35809)
+* Ensure containers are stopped on daemon startup [moby/moby#35805](https://github.com/moby/moby/pull/35805)
+* Follow containerd namespace conventions [moby/moby#35812](https://github.com/moby/moby/pull/35812)
 
 ### Swarm Mode
 
-* Replace EC Private Key with PKCS#8 PEMs [docker/swarmkit#2246](https://github.com/docker/swarmkit/pull/2246)
-* Fix IP overlap with empty EndpointSpec [docker/swarmkit #2505](https://github.com/docker/swarmkit/pull/2505)
-* Add support for Support SCTP port mapping [docker/swarmkit#2298](https://github.com/docker/swarmkit/pull/2298)
-* Do not reschedule tasks if only placement constraints change and are satisfied by the assigned node [docker/swarmkit#2496](https://github.com/docker/swarmkit/pull/2496)
-* Ensure task reaper stopChan is closed no more than once [docker/swarmkit #2491](https://github.com/docker/swarmkit/pull/2491)
-* Synchronization fixes [docker/swarmkit#2495](https://github.com/docker/swarmkit/pull/2495)
-* Add log message to indicate message send retry if streaming unimplemented [docker/swarmkit#2483](https://github.com/docker/swarmkit/pull/2483)
-* Debug logs for session, node events on dispatcher, heartbeats [docker/swarmkit#2486](https://github.com/docker/swarmkit/pull/2486)
-+ Add swarm types to bash completion event type filter [docker/cli#888](https://github.com/docker/cli/pull/888)
-- Fix issue where network inspect does not show Created time for networks in swarm scope [moby/moby#36095](https://github.com/moby/moby/pull/36095)
++ Added support for swarm service isolation mode [moby/moby#34424](https://github.com/moby/moby/pull/34424)
+- Fix task clean up for tasks that are complete [docker/swarmkit#2477](https://github.com/docker/swarmkit/pull/2477)
+
+### Packaging
+
++ Add Packaging for Fedora 27 [docker/docker-ce-packaging#59](https://github.com/docker/docker-ce-packaging/pull/59)
+* Change default versioning scheme to 0.0.0-dev unless specified for packaging [docker/docker-ce-packaging#67](https://github.com/docker/docker-ce-packaging/pull/67)
+* Pass Version to engine static builds [docker/docker-ce-packaging#70](https://github.com/docker/docker-ce-packaging/pull/70)
++ Added support for aarch64 on Debian (stretch/jessie) and Ubuntu Zesty or newer [docker/docker-ce-packaging#35](https://github.com/docker/docker-ce-packaging/pull/35)

VERSION

@@ -1 +1 @@
-18.03.1-ce-rc2
+17.12.1-ce-rc2

components/cli/.gitignore

@@ -1,12 +1,4 @@
-# if you want to ignore files created by your editor/tools,
-# please consider a global .gitignore https://help.github.com/articles/ignoring-files
-*.exe
-*.exe~
-*.orig
-.*.swp
 .DS_Store
-Thumbs.db
-.editorconfig
 /build/
 cli/winresources/rsrc_386.syso
 cli/winresources/rsrc_amd64.syso

components/cli/.mailmap

@@ -1,475 +0,0 @@
-# Generate AUTHORS: scripts/docs/generate-authors.sh
-
-# Tip for finding duplicates (besides scanning the output of AUTHORS for name
-# duplicates that aren't also email duplicates): scan the output of:
-#   git log --format='%aE - %aN' | sort -uf
-#
-# For explanation on this file format: man git-shortlog
-
-Aaron L. Xu <liker.xu@foxmail.com>
-Abhinandan Prativadi <abhi@docker.com>
-Adrien Gallouët <adrien@gallouet.fr> <angt@users.noreply.github.com>
-Ahmed Kamal <email.ahmedkamal@googlemail.com>
-Ahmet Alp Balkan <ahmetb@microsoft.com> <ahmetalpbalkan@gmail.com>
-AJ Bowen <aj@gandi.net>
-AJ Bowen <aj@gandi.net> <amy@gandi.net>
-Akihiro Matsushima <amatsusbit@gmail.com> <amatsus@users.noreply.github.com>
-Akihiro Suda <suda.akihiro@lab.ntt.co.jp> <suda.kyoto@gmail.com>
-Aleksa Sarai <asarai@suse.de>
-Aleksa Sarai <asarai@suse.de> <asarai@suse.com>
-Aleksa Sarai <asarai@suse.de> <cyphar@cyphar.com>
-Aleksandrs Fadins <aleks@s-ko.net>
-Alessandro Boch <aboch@tetrationanalytics.com> <aboch@docker.com>
-Alex Chen <alexchenunix@gmail.com> <root@localhost.localdomain>
-Alex Ellis <alexellis2@gmail.com>
-Alexander Larsson <alexl@redhat.com> <alexander.larsson@gmail.com>
-Alexander Morozov <lk4d4@docker.com>
-Alexander Morozov <lk4d4@docker.com> <lk4d4math@gmail.com>
-Alexandre Beslic <alexandre.beslic@gmail.com> <abronan@docker.com>
-Alicia Lauerman <alicia@eta.im> <allydevour@me.com>
-Allen Sun <allensun.shl@alibaba-inc.com> <allen.sun@daocloud.io>
-Allen Sun <allensun.shl@alibaba-inc.com> <shlallen1990@gmail.com>
-Andrew Weiss <andrew.weiss@docker.com> <andrew.weiss@microsoft.com>
-Andrew Weiss <andrew.weiss@docker.com> <andrew.weiss@outlook.com>
-André Martins  <aanm90@gmail.com> <martins@noironetworks.com>
-Andy Rothfusz <github@developersupport.net> <github@metaliveblog.com>
-Andy Smith <github@anarkystic.com>
-Ankush Agarwal <ankushagarwal11@gmail.com> <ankushagarwal@users.noreply.github.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <amurdaca@redhat.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <me@runcom.ninja>
-Antonio Murdaca <antonio.murdaca@gmail.com> <runcom@linux.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <runcom@redhat.com>
-Antonio Murdaca <antonio.murdaca@gmail.com> <runcom@users.noreply.github.com>
-Anuj Bahuguna <anujbahuguna.dev@gmail.com>
-Anuj Bahuguna <anujbahuguna.dev@gmail.com> <abahuguna@fiberlink.com>
-Anusha Ragunathan <anusha.ragunathan@docker.com> <anusha@docker.com>
-Arnaud Porterie <arnaud.porterie@docker.com>
-Arnaud Porterie <arnaud.porterie@docker.com> <icecrime@gmail.com>
-Arthur Gautier <baloo@gandi.net> <superbaloo+registrations.github@superbaloo.net>
-Avi Miller <avi.miller@oracle.com> <avi.miller@gmail.com>
-Ben Bonnefoy <frenchben@docker.com>
-Ben Golub <ben.golub@dotcloud.com>
-Ben Toews <mastahyeti@gmail.com> <mastahyeti@users.noreply.github.com>
-Benoit Chesneau <bchesneau@gmail.com>
-Bhiraj Butala <abhiraj.butala@gmail.com>
-Bhumika Bayani <bhumikabayani@gmail.com>
-Bilal Amarni <bilal.amarni@gmail.com> <bamarni@users.noreply.github.com>
-Bill Wang <ozbillwang@gmail.com> <SydOps@users.noreply.github.com>
-Bin Liu <liubin0329@gmail.com>
-Bin Liu <liubin0329@gmail.com> <liubin0329@users.noreply.github.com>
-Bingshen Wang <bingshen.wbs@alibaba-inc.com>
-Boaz Shuster <ripcurld.github@gmail.com>
-Brandon Philips <brandon.philips@coreos.com> <brandon@ifup.co>
-Brandon Philips <brandon.philips@coreos.com> <brandon@ifup.org>
-Brent Salisbury <brent.salisbury@docker.com> <brent@docker.com>
-Brian Goff <cpuguy83@gmail.com>
-Brian Goff <cpuguy83@gmail.com> <bgoff@cpuguy83-mbp.home>
-Brian Goff <cpuguy83@gmail.com> <bgoff@cpuguy83-mbp.local>
-Chander Govindarajan <chandergovind@gmail.com>
-Chao Wang <wangchao.fnst@cn.fujitsu.com> <chaowang@localhost.localdomain>
-Charles Hooper <charles.hooper@dotcloud.com> <chooper@plumata.com>
-Chen Chao <cc272309126@gmail.com>
-Chen Chuanliang <chen.chuanliang@zte.com.cn>
-Chen Mingjie <chenmingjie0828@163.com>
-Chen Qiu <cheney-90@hotmail.com>
-Chen Qiu <cheney-90@hotmail.com> <21321229@zju.edu.cn>
-Chris Dias <cdias@microsoft.com>
-Chris McKinnel <chris.mckinnel@tangentlabs.co.uk>
-Christopher Biscardi <biscarch@sketcht.com>
-Christopher Latham <sudosurootdev@gmail.com>
-Chun Chen <ramichen@tencent.com> <chenchun.feed@gmail.com>
-Corbin Coleman <corbin.coleman@docker.com>
-Cristian Staretu <cristian.staretu@gmail.com>
-Cristian Staretu <cristian.staretu@gmail.com> <unclejack@users.noreply.github.com>
-Cristian Staretu <cristian.staretu@gmail.com> <unclejacksons@gmail.com>
-CUI Wei <ghostplant@qq.com> cuiwei13 <cuiwei13@pku.edu.cn>
-Daehyeok Mun <daehyeok@gmail.com>
-Daehyeok Mun <daehyeok@gmail.com> <daehyeok@daehyeok-ui-MacBook-Air.local>
-Daehyeok Mun <daehyeok@gmail.com> <daehyeok@daehyeokui-MacBook-Air.local>
-Dan Feldman <danf@jfrog.com>
-Daniel Dao <dqminh@cloudflare.com>
-Daniel Dao <dqminh@cloudflare.com> <dqminh89@gmail.com>
-Daniel Garcia <daniel@danielgarcia.info>
-Daniel Gasienica <daniel@gasienica.ch> <dgasienica@zynga.com>
-Daniel Goosen <daniel.goosen@surveysampling.com> <djgoosen@users.noreply.github.com>
-Daniel Grunwell <mwgrunny@gmail.com>
-Daniel J Walsh <dwalsh@redhat.com>
-Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com> <daniel@dotcloud.com>
-Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com> <mzdaniel@glidelink.net>
-Daniel Mizyrycki <daniel.mizyrycki@dotcloud.com> <root@vagrant-ubuntu-12.10.vagrantup.com>
-Daniel Nephin <dnephin@docker.com> <dnephin@gmail.com>
-Daniel Norberg <dano@spotify.com> <daniel.norberg@gmail.com>
-Daniel Watkins <daniel@daniel-watkins.co.uk>
-Danny Yates <danny@codeaholics.org> <Danny.Yates@mailonline.co.uk>
-Darren Shepherd <darren.s.shepherd@gmail.com> <darren@rancher.com>
-Dattatraya Kumbhar <dattatraya.kumbhar@gslab.com>
-Dave Goodchild <buddhamagnet@gmail.com>
-Dave Henderson <dhenderson@gmail.com> <Dave.Henderson@ca.ibm.com>
-Dave Tucker <dt@docker.com> <dave@dtucker.co.uk>
-David M. Karr <davidmichaelkarr@gmail.com>
-David Sheets <dsheets@docker.com> <sheets@alum.mit.edu>
-David Sissitka <me@dsissitka.com>
-David Williamson <david.williamson@docker.com> <davidwilliamson@users.noreply.github.com>
-Deshi Xiao <dxiao@redhat.com> <dsxiao@dataman-inc.com>
-Deshi Xiao <dxiao@redhat.com> <xiaods@gmail.com>
-Diego Siqueira <dieg0@live.com>
-Diogo Monica <diogo@docker.com> <diogo.monica@gmail.com>
-Dominik Honnef <dominik@honnef.co> <dominikh@fork-bomb.org>
-Doug Davis <dug@us.ibm.com> <duglin@users.noreply.github.com>
-Doug Tangren <d.tangren@gmail.com>
-Elan Ruusamäe <glen@pld-linux.org>
-Elan Ruusamäe <glen@pld-linux.org> <glen@delfi.ee>
-Eric G. Noriega <enoriega@vizuri.com> <egnoriega@users.noreply.github.com>
-Eric Hanchrow <ehanchrow@ine.com> <eric.hanchrow@gmail.com>
-Eric Rosenberg <ehaydenr@gmail.com> <ehaydenr@users.noreply.github.com>
-Erica Windisch <erica@windisch.us> <eric@windisch.us>
-Erica Windisch <erica@windisch.us> <ewindisch@docker.com>
-Erik Hollensbe <github@hollensbe.org> <erik+github@hollensbe.org>
-Erwin van der Koogh <info@erronis.nl>
-Euan Kemp <euan.kemp@coreos.com> <euank@amazon.com>
-Eugen Krizo <eugen.krizo@gmail.com>
-Evan Hazlett <ejhazlett@gmail.com> <ehazlett@users.noreply.github.com>
-Evelyn Xu <evelynhsu21@gmail.com>
-Evgeny Shmarnev <shmarnev@gmail.com>
-Faiz Khan <faizkhan00@gmail.com>
-Felix Hupfeld <felix@quobyte.com> <quofelix@users.noreply.github.com>
-Felix Ruess <felix.ruess@gmail.com> <felix.ruess@roboception.de>
-Feng Yan <fy2462@gmail.com>
-Fengtu Wang <wangfengtu@huawei.com> <wangfengtu@huawei.com>
-Francisco Carriedo <fcarriedo@gmail.com>
-Frank Rosquin <frank.rosquin+github@gmail.com> <frank.rosquin@gmail.com>
-Frederick F. Kautz IV <fkautz@redhat.com> <fkautz@alumni.cmu.edu>
-Gabriel Nicolas Avellaneda <avellaneda.gabriel@gmail.com>
-Gaetan de Villele <gdevillele@gmail.com>
-Gang Qiao <qiaohai8866@gmail.com> <1373319223@qq.com>
-George Kontridze <george@bugsnag.com>
-Gerwim Feiken <g.feiken@tfe.nl> <gerwim@gmail.com>
-Giampaolo Mancini <giampaolo@trampolineup.com>
-Gopikannan Venugopalsamy <gopikannan.venugopalsamy@gmail.com>
-Gou Rao <gou@portworx.com> <gourao@users.noreply.github.com>
-Greg Stephens <greg@udon.org>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <charmes.guillaume@gmail.com>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <guillaume.charmes@dotcloud.com>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <guillaume@charmes.net>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <guillaume@docker.com>
-Guillaume J. Charmes <guillaume.charmes@docker.com> <guillaume@dotcloud.com>
-Gurjeet Singh <gurjeet@singh.im> <singh.gurjeet@gmail.com>
-Gustav Sinder <gustav.sinder@gmail.com>
-Günther Jungbluth <gunther@gameslabs.net>
-Hakan Özler <hakan.ozler@kodcu.com>
-Hao Shu Wei <haosw@cn.ibm.com>
-Hao Shu Wei <haosw@cn.ibm.com> <haoshuwei1989@163.com>
-Harald Albers <github@albersweb.de> <albers@users.noreply.github.com>
-Harold Cooper <hrldcpr@gmail.com>
-Harry Zhang <harryz@hyper.sh> <harryzhang@zju.edu.cn>
-Harry Zhang <harryz@hyper.sh> <resouer@163.com>
-Harry Zhang <harryz@hyper.sh> <resouer@gmail.com>
-Harry Zhang <resouer@163.com>
-Harshal Patil <harshal.patil@in.ibm.com> <harche@users.noreply.github.com>
-Helen Xie <chenjg@harmonycloud.cn>
-Hollie Teal <hollie@docker.com>
-Hollie Teal <hollie@docker.com> <hollie.teal@docker.com>
-Hollie Teal <hollie@docker.com> <hollietealok@users.noreply.github.com>
-Hu Keping <hukeping@huawei.com>
-Huu Nguyen <huu@prismskylabs.com> <whoshuu@gmail.com>
-Hyzhou Zhy <hyzhou.zhy@alibaba-inc.com>
-Hyzhou Zhy <hyzhou.zhy@alibaba-inc.com> <1187766782@qq.com>
-Ilya Khlopotov <ilya.khlopotov@gmail.com>
-Jack Laxson <jackjrabbit@gmail.com>
-Jacob Atzen <jacob@jacobatzen.dk> <jatzen@gmail.com>
-Jacob Tomlinson <jacob@tom.linson.uk> <jacobtomlinson@users.noreply.github.com>
-Jaivish Kothari <janonymous.codevulture@gmail.com>
-Jamie Hannaford <jamie@limetree.org> <jamie.hannaford@rackspace.com>
-Jean-Baptiste Barth <jeanbaptiste.barth@gmail.com>
-Jean-Baptiste Dalido <jeanbaptiste@appgratis.com>
-Jean-Tiare Le Bigot <jt@yadutaf.fr> <admin@jtlebi.fr>
-Jeff Anderson <jeff@docker.com> <jefferya@programmerq.net>
-Jeff Nickoloff <jeff.nickoloff@gmail.com> <jeff@allingeek.com>
-Jeroen Franse <jeroenfranse@gmail.com>
-Jessica Frazelle <jessfraz@google.com>
-Jessica Frazelle <jessfraz@google.com> <acidburn@docker.com>
-Jessica Frazelle <jessfraz@google.com> <acidburn@google.com>
-Jessica Frazelle <jessfraz@google.com> <jess@docker.com>
-Jessica Frazelle <jessfraz@google.com> <jess@mesosphere.com>
-Jessica Frazelle <jessfraz@google.com> <jfrazelle@users.noreply.github.com>
-Jessica Frazelle <jessfraz@google.com> <me@jessfraz.com>
-Jessica Frazelle <jessfraz@google.com> <princess@docker.com>
-Jim Galasyn <jim.galasyn@docker.com>
-Jiuyue Ma <majiuyue@huawei.com>
-Joey Geiger <jgeiger@gmail.com>
-Joffrey F <joffrey@docker.com>
-Joffrey F <joffrey@docker.com> <f.joffrey@gmail.com>
-Joffrey F <joffrey@docker.com> <joffrey@dotcloud.com>
-Johan Euphrosine <proppy@google.com> <proppy@aminche.com>
-John Harris <john@johnharris.io>
-John Howard (VM) <John.Howard@microsoft.com>
-John Howard (VM) <John.Howard@microsoft.com> <jhoward@microsoft.com>
-John Howard (VM) <John.Howard@microsoft.com> <jhoward@ntdev.microsoft.com>
-John Howard (VM) <John.Howard@microsoft.com> <jhowardmsft@users.noreply.github.com>
-John Howard (VM) <John.Howard@microsoft.com> <john.howard@microsoft.com>
-John Stephens <johnstep@docker.com> <johnstep@users.noreply.github.com>
-Jordan Arentsen <blissdev@gmail.com>
-Jordan Jennings <jjn2009@gmail.com> <jjn2009@users.noreply.github.com>
-Jorit Kleine-Möllhoff <joppich@bricknet.de> <joppich@users.noreply.github.com>
-Jose Diaz-Gonzalez <jose@seatgeek.com> <josegonzalez@users.noreply.github.com>
-Josh Eveleth <joshe@opendns.com> <jeveleth@users.noreply.github.com>
-Josh Hawn <josh.hawn@docker.com> <jlhawn@berkeley.edu>
-Josh Horwitz <horwitz@addthis.com> <horwitzja@gmail.com>
-Josh Soref <jsoref@gmail.com> <jsoref@users.noreply.github.com>
-Josh Wilson <josh.wilson@fivestars.com> <jcwilson@users.noreply.github.com>
-Joyce Jang <mail@joycejang.com>
-Julien Bordellier <julienbordellier@gmail.com> <git@julienbordellier.com>
-Julien Bordellier <julienbordellier@gmail.com> <me@julienbordellier.com>
-Justin Cormack <justin.cormack@docker.com>
-Justin Cormack <justin.cormack@docker.com> <justin.cormack@unikernel.com>
-Justin Cormack <justin.cormack@docker.com> <justin@specialbusservice.com>
-Justin Simonelis <justin.p.simonelis@gmail.com> <justin.simonelis@PTS-JSIMON2.toronto.exclamation.com>
-Jérôme Petazzoni <jerome.petazzoni@docker.com> <jerome.petazzoni@dotcloud.com>
-Jérôme Petazzoni <jerome.petazzoni@docker.com> <jerome.petazzoni@gmail.com>
-Jérôme Petazzoni <jerome.petazzoni@docker.com> <jp@enix.org>
-K. Heller <pestophagous@gmail.com> <pestophagous@users.noreply.github.com>
-Kai Qiang Wu (Kennan) <wkq5325@gmail.com>
-Kai Qiang Wu (Kennan) <wkq5325@gmail.com> <wkqwu@cn.ibm.com>
-Kamil Domański <kamil@domanski.co>
-Kamjar Gerami <kami.gerami@gmail.com>
-Kat Samperi <kat.samperi@gmail.com> <kizzie@users.noreply.github.com>
-Ken Cochrane <kencochrane@gmail.com> <KenCochrane@gmail.com>
-Ken Herner <kherner@progress.com> <chosenken@gmail.com>
-Kenfe-Mickaël Laventure <mickael.laventure@gmail.com>
-Kevin Feyrer <kevin.feyrer@btinternet.com> <kevinfeyrer@users.noreply.github.com>
-Kevin Kern <kaiwentan@harmonycloud.cn>
-Kevin Meredith <kevin.m.meredith@gmail.com>
-Kir Kolyshkin <kolyshkin@gmail.com>
-Kir Kolyshkin <kolyshkin@gmail.com> <kir@openvz.org>
-Kir Kolyshkin <kolyshkin@gmail.com> <kolyshkin@users.noreply.github.com>
-Konrad Kleine <konrad.wilhelm.kleine@gmail.com> <kwk@users.noreply.github.com>
-Konstantin Gribov <grossws@gmail.com>
-Konstantin Pelykh <kpelykh@zettaset.com>
-Kotaro Yoshimatsu <kotaro.yoshimatsu@gmail.com>
-Kunal Kushwaha <kushwaha_kunal_v7@lab.ntt.co.jp> <kunal.kushwaha@gmail.com>
-Lajos Papp <lajos.papp@sequenceiq.com> <lalyos@yahoo.com>
-Lei Jitang <leijitang@huawei.com>
-Lei Jitang <leijitang@huawei.com> <leijitang@gmail.com>
-Liang Mingqiang <mqliang.zju@gmail.com>
-Liang-Chi Hsieh <viirya@gmail.com>
-Liao Qingwei <liaoqingwei@huawei.com>
-Linus Heckemann <lheckemann@twig-world.com>
-Linus Heckemann <lheckemann@twig-world.com> <anonymouse2048@gmail.com>
-Lokesh Mandvekar <lsm5@fedoraproject.org> <lsm5@redhat.com>
-Lorenzo Fontana <lo@linux.com> <fontanalorenzo@me.com>
-Louis Opter <kalessin@kalessin.fr>
-Louis Opter <kalessin@kalessin.fr> <louis@dotcloud.com>
-Luca Favatella <luca.favatella@erlang-solutions.com> <lucafavatella@users.noreply.github.com>
-Luke Marsden <me@lukemarsden.net> <luke@digital-crocus.com>
-Lyn <energylyn@zju.edu.cn>
-Lynda O'Leary <lyndaoleary29@gmail.com>
-Lynda O'Leary <lyndaoleary29@gmail.com> <lyndaoleary@hotmail.com>
-Ma Müller <mueller-ma@users.noreply.github.com>
-Madhan Raj Mookkandy <MadhanRaj.Mookkandy@microsoft.com> <madhanm@microsoft.com>
-Madhu Venugopal <madhu@socketplane.io> <madhu@docker.com>
-Mageee <fangpuyi@foxmail.com> <21521230.zju.edu.cn>
-Mansi Nahar <mmn4185@rit.edu> <mansi.nahar@macbookpro-mansinahar.local>
-Mansi Nahar <mmn4185@rit.edu> <mansinahar@users.noreply.github.com>
-Marc Abramowitz <marc@marc-abramowitz.com> <msabramo@gmail.com>
-Marcelo Horacio Fortino <info@fortinux.com> <fortinux@users.noreply.github.com>
-Marcus Linke <marcus.linke@gmx.de>
-Marianna Tessel <mtesselh@gmail.com>
-Mark Oates <fl0yd@me.com>
-Markan Patel <mpatel678@gmail.com>
-Markus Kortlang <hyp3rdino@googlemail.com> <markus.kortlang@lhsystems.com>
-Martin Redmond <redmond.martin@gmail.com> <martin@tinychat.com>
-Martin Redmond <redmond.martin@gmail.com> <xgithub@redmond5.com>
-Mary Anthony <mary.anthony@docker.com> <mary@docker.com>
-Mary Anthony <mary.anthony@docker.com> <moxieandmore@gmail.com>
-Mary Anthony <mary.anthony@docker.com> moxiegirl <mary@docker.com>
-Mateusz Major <apkd@users.noreply.github.com>
-Matt Bentley <matt.bentley@docker.com> <mbentley@mbentley.net>
-Matt Schurenko <matt.schurenko@gmail.com>
-Matt Williams <mattyw@me.com>
-Matt Williams <mattyw@me.com> <gh@mattyw.net>
-Matthew Heon <mheon@redhat.com> <mheon@mheonlaptop.redhat.com>
-Matthew Mosesohn <raytrac3r@gmail.com>
-Matthew Mueller <mattmuelle@gmail.com>
-Matthias Kühnle <git.nivoc@neverbox.com> <kuehnle@online.de>
-Mauricio Garavaglia <mauricio@medallia.com> <mauriciogaravaglia@gmail.com>
-Michael Crosby <michael@docker.com> <crosby.michael@gmail.com>
-Michael Crosby <michael@docker.com> <crosbymichael@gmail.com>
-Michael Crosby <michael@docker.com> <michael@crosbymichael.com>
-Michael Hudson-Doyle <michael.hudson@canonical.com> <michael.hudson@linaro.org>
-Michael Huettermann <michael@huettermann.net>
-Michael Käufl <docker@c.michael-kaeufl.de> <michael-k@users.noreply.github.com>
-Michael Spetsiotis <michael_spets@hotmail.com>
-Michal Minář <miminar@redhat.com>
-Miguel Angel Alvarez Cabrerizo <doncicuto@gmail.com> <30386061+doncicuto@users.noreply.github.com>
-Miguel Angel Fernández <elmendalerenda@gmail.com>
-Mihai Borobocea <MihaiBorob@gmail.com> <MihaiBorobocea@gmail.com>
-Mike Casas <mkcsas0@gmail.com> <mikecasas@users.noreply.github.com>
-Mike Goelzer <mike.goelzer@docker.com> <mgoelzer@docker.com>
-Milind Chawre <milindchawre@gmail.com>
-Misty Stanley-Jones <misty@docker.com> <misty@apache.org>
-Mohit Soni <mosoni@ebay.com> <mohitsoni1989@gmail.com>
-Moorthy RS <rsmoorthy@gmail.com> <rsmoorthy@users.noreply.github.com>
-Moysés Borges <moysesb@gmail.com>
-Moysés Borges <moysesb@gmail.com> <moyses.furtado@wplex.com.br>
-Nace Oroz <orkica@gmail.com>
-Nathan LeClaire <nathan.leclaire@docker.com> <nathan.leclaire@gmail.com>
-Nathan LeClaire <nathan.leclaire@docker.com> <nathanleclaire@gmail.com>
-Neil Horman <nhorman@tuxdriver.com> <nhorman@hmswarspite.think-freely.org>
-Nick Russo <nicholasjamesrusso@gmail.com> <nicholasrusso@icloud.com>
-Nicolas Borboën <ponsfrilus@gmail.com> <ponsfrilus@users.noreply.github.com>
-Nigel Poulton <nigelpoulton@hotmail.com>
-Nik Nyby <nikolas@gnu.org> <nnyby@columbia.edu>
-Nolan Darilek <nolan@thewordnerd.info>
-O.S. Tezer <ostezer@gmail.com>
-O.S. Tezer <ostezer@gmail.com> <ostezer@users.noreply.github.com>
-Oh Jinkyun <tintypemolly@gmail.com> <tintypemolly@Ohui-MacBook-Pro.local>
-Ouyang Liduo <oyld0210@163.com>
-Patrick Stapleton <github@gdi2290.com>
-Paul Liljenberg <liljenberg.paul@gmail.com> <letters@paulnotcom.se>
-Pavel Tikhomirov <ptikhomirov@virtuozzo.com> <ptikhomirov@parallels.com>
-Pawel Konczalski <mail@konczalski.de>
-Peter Choi <phkchoi89@gmail.com> <reikani@Peters-MacBook-Pro.local>
-Peter Dave Hello <hsu@peterdavehello.org> <PeterDaveHello@users.noreply.github.com>
-Peter Jaffe <pjaffe@nevo.com>
-Peter Nagy <xificurC@gmail.com> <pnagy@gratex.com>
-Peter Waller <p@pwaller.net> <peter@scraperwiki.com>
-Phil Estes <estesp@linux.vnet.ibm.com> <estesp@gmail.com>
-Philip Alexander Etling <paetling@gmail.com>
-Philipp Gillé <philipp.gille@gmail.com> <philippgille@users.noreply.github.com>
-Qiang Huang <h.huangqiang@huawei.com>
-Qiang Huang <h.huangqiang@huawei.com> <qhuang@10.0.2.15>
-Ray Tsang <rayt@google.com> <saturnism@users.noreply.github.com>
-Renaud Gaubert <rgaubert@nvidia.com> <renaud.gaubert@gmail.com>
-Robert Terhaar <rterhaar@atlanticdynamic.com> <robbyt@users.noreply.github.com>
-Roberto G. Hashioka <roberto.hashioka@docker.com> <roberto_hashioka@hotmail.com>
-Roberto Muñoz Fernández <robertomf@gmail.com> <roberto.munoz.fernandez.contractor@bbva.com>
-Roman Dudin <katrmr@gmail.com> <decadent@users.noreply.github.com>
-Ross Boucher <rboucher@gmail.com>
-Runshen Zhu <runshen.zhu@gmail.com>
-Ryan Stelly <ryan.stelly@live.com>
-Sakeven Jiang <jc5930@sina.cn>
-Sandeep Bansal <sabansal@microsoft.com>
-Sandeep Bansal <sabansal@microsoft.com> <msabansal@microsoft.com>
-Sargun Dhillon <sargun@netflix.com> <sargun@sargun.me>
-Sean Lee <seanlee@tw.ibm.com> <scaleoutsean@users.noreply.github.com>
-Sebastiaan van Stijn <github@gone.nl> <sebastiaan@ws-key-sebas3.dpi1.dpi>
-Sebastiaan van Stijn <github@gone.nl> <thaJeztah@users.noreply.github.com>
-Shaun Kaasten <shaunk@gmail.com>
-Shawn Landden <shawn@churchofgit.com> <shawnlandden@gmail.com>
-Shengbo Song <thomassong@tencent.com>
-Shengbo Song <thomassong@tencent.com> <mymneo@163.com>
-Shih-Yuan Lee <fourdollars@gmail.com>
-Shishir Mahajan <shishir.mahajan@redhat.com> <smahajan@redhat.com>
-Shukui Yang <yangshukui@huawei.com>
-Shuwei Hao <haosw@cn.ibm.com>
-Shuwei Hao <haosw@cn.ibm.com> <haoshuwei24@gmail.com>
-Sidhartha Mani <sidharthamn@gmail.com>
-Sjoerd Langkemper <sjoerd-github@linuxonly.nl> <sjoerd@byte.nl>
-Solomon Hykes <solomon@docker.com> <s@docker.com>
-Solomon Hykes <solomon@docker.com> <solomon.hykes@dotcloud.com>
-Solomon Hykes <solomon@docker.com> <solomon@dotcloud.com>
-Soshi Katsuta <soshi.katsuta@gmail.com>
-Soshi Katsuta <soshi.katsuta@gmail.com> <katsuta_soshi@cyberagent.co.jp>
-Sridhar Ratnakumar <sridharr@activestate.com>
-Sridhar Ratnakumar <sridharr@activestate.com> <github@srid.name>
-Srini Brahmaroutu <srbrahma@us.ibm.com> <sbrahma@us.ibm.com>
-Srinivasan Srivatsan <srinivasan.srivatsan@hpe.com> <srinsriv@users.noreply.github.com>
-Stefan Berger <stefanb@linux.vnet.ibm.com>
-Stefan Berger <stefanb@linux.vnet.ibm.com> <stefanb@us.ibm.com>
-Stefan J. Wernli <swernli@microsoft.com> <swernli@ntdev.microsoft.com>
-Stefan S. <tronicum@user.github.com>
-Stephen Day <stephen.day@docker.com>
-Stephen Day <stephen.day@docker.com> <stevvooe@users.noreply.github.com>
-Steve Desmond <steve@vtsv.ca> <stevedesmond-ca@users.noreply.github.com>
-Sun Gengze <690388648@qq.com>
-Sun Jianbo <wonderflow.sun@gmail.com>
-Sun Jianbo <wonderflow.sun@gmail.com> <wonderflow@zju.edu.cn>
-Sven Dowideit <SvenDowideit@home.org.au>
-Sven Dowideit <SvenDowideit@home.org.au> <sven@t440s.home.gateway>
-Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@docker.com>
-Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@fosiki.com>
-Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@home.org.au>
-Sven Dowideit <SvenDowideit@home.org.au> <SvenDowideit@users.noreply.github.com>
-Sven Dowideit <SvenDowideit@home.org.au> <¨SvenDowideit@home.org.au¨>
-Sylvain Bellemare <sylvain@ascribe.io>
-Sylvain Bellemare <sylvain@ascribe.io> <sylvain.bellemare@ezeep.com>
-Tangi Colin <tangicolin@gmail.com>
-Tejesh Mehta <tejesh.mehta@gmail.com> <tj@init.me>
-Thatcher Peskens <thatcher@docker.com>
-Thatcher Peskens <thatcher@docker.com> <thatcher@dotcloud.com>
-Thatcher Peskens <thatcher@docker.com> <thatcher@gmx.net>
-Thomas Gazagnaire <thomas@gazagnaire.org> <thomas@gazagnaire.com>
-Thomas Krzero <thomas.kovatchitch@gmail.com>
-Thomas Léveil <thomasleveil@gmail.com>
-Thomas Léveil <thomasleveil@gmail.com> <thomasleveil@users.noreply.github.com>
-Tibor Vass <teabee89@gmail.com> <tibor@docker.com>
-Tibor Vass <teabee89@gmail.com> <tiborvass@users.noreply.github.com>
-Tim Bart <tim@fewagainstmany.com>
-Tim Bosse <taim@bosboot.org> <maztaim@users.noreply.github.com>
-Tim Ruffles <oi@truffles.me.uk> <timruffles@googlemail.com>
-Tim Terhorst <mynamewastaken+git@gmail.com>
-Tim Zju <21651152@zju.edu.cn>
-Timothy Hobbs <timothyhobbs@seznam.cz>
-Toli Kuznets <toli@docker.com>
-Tom Barlow <tomwbarlow@gmail.com>
-Tom Sweeney <tsweeney@redhat.com>
-Tõnis Tiigi <tonistiigi@gmail.com>
-Trishna Guha <trishnaguha17@gmail.com>
-Tristan Carel <tristan@cogniteev.com>
-Tristan Carel <tristan@cogniteev.com> <tristan.carel@gmail.com>
-Umesh Yadav <umesh4257@gmail.com>
-Umesh Yadav <umesh4257@gmail.com> <dungeonmaster18@users.noreply.github.com>
-Victor Lyuboslavsky <victor@victoreda.com>
-Victor Vieux <victor.vieux@docker.com> <dev@vvieux.com>
-Victor Vieux <victor.vieux@docker.com> <victor.vieux@dotcloud.com>
-Victor Vieux <victor.vieux@docker.com> <victor@docker.com>
-Victor Vieux <victor.vieux@docker.com> <victor@dotcloud.com>
-Victor Vieux <victor.vieux@docker.com> <victorvieux@gmail.com>
-Victor Vieux <victor.vieux@docker.com> <vieux@docker.com>
-Viktor Vojnovski <viktor.vojnovski@amadeus.com> <vojnovski@gmail.com>
-Vincent Batts <vbatts@redhat.com> <vbatts@hashbangbash.com>
-Vincent Bernat <Vincent.Bernat@exoscale.ch> <bernat@luffy.cx>
-Vincent Bernat <Vincent.Bernat@exoscale.ch> <vincent@bernat.im>
-Vincent Demeester <vincent.demeester@docker.com> <vincent+github@demeester.fr>
-Vincent Demeester <vincent.demeester@docker.com> <vincent@demeester.fr>
-Vincent Demeester <vincent.demeester@docker.com> <vincent@sbr.pm>
-Vishnu Kannan <vishnuk@google.com>
-Vladimir Rutsky <altsysrq@gmail.com> <iamironbob@gmail.com>
-Walter Stanish <walter@pratyeka.org>
-Wang Guoliang <liangcszzu@163.com>
-Wang Jie <wangjie5@chinaskycloud.com>
-Wang Ping <present.wp@icloud.com>
-Wang Xing <hzwangxing@corp.netease.com> <root@localhost>
-Wang Yuexiao <wang.yuexiao@zte.com.cn>
-Wayne Chang <wayne@neverfear.org>
-Wayne Song <wsong@docker.com> <wsong@users.noreply.github.com>
-Wei Wu <wuwei4455@gmail.com> cizixs <cizixs@163.com>
-Wenjun Tang <tangwj2@lenovo.com> <dodia@163.com>
-Wewang Xiaorenfine <wang.xiaoren@zte.com.cn>
-Will Weaver <monkey@buildingbananas.com>
-Xianglin Gao <xlgao@zju.edu.cn>
-Xianlu Bird <xianlubird@gmail.com>
-Xiaoyu Zhang <zhang.xiaoyu33@zte.com.cn>
-Xuecong Liao <satorulogic@gmail.com>
-Yamasaki Masahide <masahide.y@gmail.com>
-Yao Zaiyong <yaozaiyong@hotmail.com>
-Yassine Tijani <yasstij11@gmail.com>
-Yazhong Liu <yorkiefixer@gmail.com>
-Yestin Sun <sunyi0804@gmail.com> <yestin.sun@polyera.com>
-Yi EungJun <eungjun.yi@navercorp.com> <semtlenori@gmail.com>
-Ying Li <ying.li@docker.com>
-Ying Li <ying.li@docker.com> <cyli@twistedmatrix.com>
-Yong Tang <yong.tang.github@outlook.com> <yongtang@users.noreply.github.com>
-Yosef Fertel <yfertel@gmail.com> <frosforever@users.noreply.github.com>
-Yu Changchun <yuchangchun1@huawei.com>
-Yu Chengxia <yuchengxia@huawei.com>
-Yu Peng <yu.peng36@zte.com.cn>
-Yu Peng <yu.peng36@zte.com.cn> <yupeng36@zte.com.cn>
-Zachary Jaffee <zjaffee@us.ibm.com> <zij@case.edu>
-Zachary Jaffee <zjaffee@us.ibm.com> <zjaffee@apache.org>
-ZhangHang <stevezhang2014@gmail.com>
-Zhenkun Bi <bi.zhenkun@zte.com.cn>
-Zhou Hao <zhouhao@cn.fujitsu.com>
-Zhu Kunjia <zhu.kunjia@zte.com.cn>
-Zou Yu <zouyu7@huawei.com>
-

components/cli/AUTHORS

@@ -1,638 +0,0 @@
-# This file lists all individuals having contributed content to the repository.
-# For how it is generated, see `scripts/docs/generate-authors.sh`.
-
-Aanand Prasad <aanand.prasad@gmail.com>
-Aaron L. Xu <liker.xu@foxmail.com>
-Aaron Lehmann <aaron.lehmann@docker.com>
-Aaron.L.Xu <likexu@harmonycloud.cn>
-Abdur Rehman <abdur_rehman@mentor.com>
-Abhinandan Prativadi <abhi@docker.com>
-Abin Shahab <ashahab@altiscale.com>
-Addam Hardy <addam.hardy@gmail.com>
-Adolfo Ochagavía <aochagavia92@gmail.com>
-Adrien Duermael <adrien@duermael.com>
-Adrien Folie <folie.adrien@gmail.com>
-Ahmet Alp Balkan <ahmetb@microsoft.com>
-Aidan Feldman <aidan.feldman@gmail.com>
-Aidan Hobson Sayers <aidanhs@cantab.net>
-AJ Bowen <aj@gandi.net>
-Akihiro Suda <suda.akihiro@lab.ntt.co.jp>
-Akim Demaille <akim.demaille@docker.com>
-Alan Thompson <cloojure@gmail.com>
-Albert Callarisa <shark234@gmail.com>
-Aleksa Sarai <asarai@suse.de>
-Alessandro Boch <aboch@tetrationanalytics.com>
-Alex Mavrogiannis <alex.mavrogiannis@docker.com>
-Alexander Boyd <alex@opengroove.org>
-Alexander Larsson <alexl@redhat.com>
-Alexander Morozov <lk4d4@docker.com>
-Alexandre González <agonzalezro@gmail.com>
-Alfred Landrum <alfred.landrum@docker.com>
-Alicia Lauerman <alicia@eta.im>
-Allen Sun <allensun.shl@alibaba-inc.com>
-Alvin Deng <alvin.q.deng@utexas.edu>
-Amen Belayneh <amenbelayneh@gmail.com>
-Amir Goldstein <amir73il@aquasec.com>
-Amit Krishnan <amit.krishnan@oracle.com>
-Amit Shukla <amit.shukla@docker.com>
-Amy Lindburg <amy.lindburg@docker.com>
-Andrea Luzzardi <aluzzardi@gmail.com>
-Andreas Köhler <andi5.py@gmx.net>
-Andrew France <andrew@avito.co.uk>
-Andrew Hsu <andrewhsu@docker.com>
-Andrew Macpherson <hopscotch23@gmail.com>
-Andrew McDonnell <bugs@andrewmcdonnell.net>
-Andrew Po <absourd.noise@gmail.com>
-Andrey Petrov <andrey.petrov@shazow.net>
-André Martins <aanm90@gmail.com>
-Andy Goldstein <agoldste@redhat.com>
-Andy Rothfusz <github@developersupport.net>
-Anil Madhavapeddy <anil@recoil.org>
-Ankush Agarwal <ankushagarwal11@gmail.com>
-Anton Polonskiy <anton.polonskiy@gmail.com>
-Antonio Murdaca <antonio.murdaca@gmail.com>
-Antonis Kalipetis <akalipetis@gmail.com>
-Anusha Ragunathan <anusha.ragunathan@docker.com>
-Arash Deshmeh <adeshmeh@ca.ibm.com>
-Arnaud Porterie <arnaud.porterie@docker.com>
-Ashwini Oruganti <ashwini.oruganti@gmail.com>
-Azat Khuyiyakhmetov <shadow_uz@mail.ru>
-Bardia Keyoumarsi <bkeyouma@ucsc.edu>
-Barnaby Gray <barnaby@pickle.me.uk>
-Bastiaan Bakker <bbakker@xebia.com>
-BastianHofmann <bastianhofmann@me.com>
-Ben Bonnefoy <frenchben@docker.com>
-Ben Firshman <ben@firshman.co.uk>
-Benjamin Boudreau <boudreau.benjamin@gmail.com>
-Bhumika Bayani <bhumikabayani@gmail.com>
-Bill Wang <ozbillwang@gmail.com>
-Bin Liu <liubin0329@gmail.com>
-Bingshen Wang <bingshen.wbs@alibaba-inc.com>
-Boaz Shuster <ripcurld.github@gmail.com>
-Boris Pruessmann <boris@pruessmann.org>
-Bradley Cicenas <bradley.cicenas@gmail.com>
-Brandon Philips <brandon.philips@coreos.com>
-Brent Salisbury <brent.salisbury@docker.com>
-Bret Fisher <bret@bretfisher.com>
-Brian (bex) Exelbierd <bexelbie@redhat.com>
-Brian Goff <cpuguy83@gmail.com>
-Bryan Bess <squarejaw@bsbess.com>
-Bryan Boreham <bjboreham@gmail.com>
-Bryan Murphy <bmurphy1976@gmail.com>
-bryfry <bryon.fryer@gmail.com>
-Cameron Spear <cameronspear@gmail.com>
-Cao Weiwei <cao.weiwei30@zte.com.cn>
-Carlo Mion <mion00@gmail.com>
-Carlos Alexandro Becker <caarlos0@gmail.com>
-Ce Gao <ce.gao@outlook.com>
-Cedric Davies <cedricda@microsoft.com>
-Cezar Sa Espinola <cezarsa@gmail.com>
-Chao Wang <wangchao.fnst@cn.fujitsu.com>
-Charles Chan <charleswhchan@users.noreply.github.com>
-Charles Law <claw@conduce.com>
-Charles Smith <charles.smith@docker.com>
-Charlie Drage <charlie@charliedrage.com>
-ChaYoung You <yousbe@gmail.com>
-Chen Chuanliang <chen.chuanliang@zte.com.cn>
-Chen Hanxiao <chenhanxiao@cn.fujitsu.com>
-Chen Mingjie <chenmingjie0828@163.com>
-Chen Qiu <cheney-90@hotmail.com>
-Chris Gavin <chris@chrisgavin.me>
-Chris Gibson <chris@chrisg.io>
-Chris McKinnel <chrismckinnel@gmail.com>
-Chris Snow <chsnow123@gmail.com>
-Chris Weyl <cweyl@alumni.drew.edu>
-Christian Persson <saser@live.se>
-Christian Stefanescu <st.chris@gmail.com>
-Christophe Robin <crobin@nekoo.com>
-Christophe Vidal <kriss@krizalys.com>
-Christopher Biscardi <biscarch@sketcht.com>
-Christopher Jones <tophj@linux.vnet.ibm.com>
-Christy Perez <christy@linux.vnet.ibm.com>
-Chun Chen <ramichen@tencent.com>
-Clinton Kitson <clintonskitson@gmail.com>
-Coenraad Loubser <coenraad@wish.org.za>
-Colin Hebert <hebert.colin@gmail.com>
-Collin Guarino <collin.guarino@gmail.com>
-Colm Hally <colmhally@gmail.com>
-Corey Farrell <git@cfware.com>
-Cristian Staretu <cristian.staretu@gmail.com>
-Daehyeok Mun <daehyeok@gmail.com>
-Dafydd Crosby <dtcrsby@gmail.com>
-dalanlan <dalanlan925@gmail.com>
-Damien Nadé <github@livna.org>
-Dan Cotora <dan@bluevision.ro>
-Daniel Dao <dqminh@cloudflare.com>
-Daniel Farrell <dfarrell@redhat.com>
-Daniel Gasienica <daniel@gasienica.ch>
-Daniel Goosen <daniel.goosen@surveysampling.com>
-Daniel Hiltgen <daniel.hiltgen@docker.com>
-Daniel J Walsh <dwalsh@redhat.com>
-Daniel Nephin <dnephin@docker.com>
-Daniel Norberg <dano@spotify.com>
-Daniel Watkins <daniel@daniel-watkins.co.uk>
-Daniel Zhang <jmzwcn@gmail.com>
-Danny Berger <dpb587@gmail.com>
-Darren Shepherd <darren.s.shepherd@gmail.com>
-Darren Stahl <darst@microsoft.com>
-Dattatraya Kumbhar <dattatraya.kumbhar@gslab.com>
-Dave Goodchild <buddhamagnet@gmail.com>
-Dave Henderson <dhenderson@gmail.com>
-Dave Tucker <dt@docker.com>
-David Calavera <david.calavera@gmail.com>
-David Cramer <davcrame@cisco.com>
-David Dooling <dooling@gmail.com>
-David Gageot <david@gageot.net>
-David Lechner <david@lechnology.com>
-David Sheets <dsheets@docker.com>
-David Williamson <david.williamson@docker.com>
-David Xia <dxia@spotify.com>
-David Young <yangboh@cn.ibm.com>
-Deng Guangxing <dengguangxing@huawei.com>
-Denis Defreyne <denis@soundcloud.com>
-Denis Gladkikh <denis@gladkikh.email>
-Denis Ollier <larchunix@users.noreply.github.com>
-Dennis Docter <dennis@d23.nl>
-Derek McGowan <derek@mcgstyle.net>
-Deshi Xiao <dxiao@redhat.com>
-Dharmit Shah <shahdharmit@gmail.com>
-Dhawal Yogesh Bhanushali <dbhanushali@vmware.com>
-Dieter Reuter <dieter.reuter@me.com>
-Dima Stopel <dima@twistlock.com>
-Dimitry Andric <d.andric@activevideo.com>
-Ding Fei <dingfei@stars.org.cn>
-Diogo Monica <diogo@docker.com>
-Dmitry Gusev <dmitry.gusev@gmail.com>
-Dmitry Smirnov <onlyjob@member.fsf.org>
-Dmitry V. Krivenok <krivenok.dmitry@gmail.com>
-Don Kjer <don.kjer@gmail.com>
-Dong Chen <dongluo.chen@docker.com>
-Doug Davis <dug@us.ibm.com>
-Drew Erny <drew.erny@docker.com>
-Ed Costello <epc@epcostello.com>
-Eli Uriegas <eli.uriegas@docker.com>
-Eli Uriegas <seemethere101@gmail.com>
-Elias Faxö <elias.faxo@tre.se>
-Eric G. Noriega <enoriega@vizuri.com>
-Eric Rosenberg <ehaydenr@gmail.com>
-Eric Sage <eric.david.sage@gmail.com>
-Eric-Olivier Lamey <eo@lamey.me>
-Erica Windisch <erica@windisch.us>
-Erik Hollensbe <github@hollensbe.org>
-Erik St. Martin <alakriti@gmail.com>
-Ethan Haynes <ethanhaynes@alumni.harvard.edu>
-Eugene Yakubovich <eugene.yakubovich@coreos.com>
-Evan Allrich <evan@unguku.com>
-Evan Hazlett <ejhazlett@gmail.com>
-Evan Krall <krall@yelp.com>
-Evelyn Xu <evelynhsu21@gmail.com>
-Everett Toews <everett.toews@rackspace.com>
-Fabio Falci <fabiofalci@gmail.com>
-Fabrizio Soppelsa <fsoppelsa@mirantis.com>
-Felix Hupfeld <felix@quobyte.com>
-Felix Rabe <felix@rabe.io>
-Flavio Crisciani <flavio.crisciani@docker.com>
-Florian Klein <florian.klein@free.fr>
-Foysal Iqbal <foysal.iqbal.fb@gmail.com>
-Fred Lifton <fred.lifton@docker.com>
-Frederick F. Kautz IV <fkautz@redhat.com>
-Frederik Nordahl Jul Sabroe <frederikns@gmail.com>
-Frieder Bluemle <frieder.bluemle@gmail.com>
-Gabriel Nicolas Avellaneda <avellaneda.gabriel@gmail.com>
-Gaetan de Villele <gdevillele@gmail.com>
-Gang Qiao <qiaohai8866@gmail.com>
-Gary Schaetz <gary@schaetzkc.com>
-Genki Takiuchi <genki@s21g.com>
-George MacRorie <gmacr31@gmail.com>
-George Xie <georgexsh@gmail.com>
-Gianluca Borello <g.borello@gmail.com>
-Gildas Cuisinier <gildas.cuisinier@gcuisinier.net>
-Gou Rao <gou@portworx.com>
-Grant Reaber <grant.reaber@gmail.com>
-Greg Pflaum <gpflaum@users.noreply.github.com>
-Guilhem Lettron <guilhem+github@lettron.fr>
-Guillaume J. Charmes <guillaume.charmes@docker.com>
-gwx296173 <gaojing3@huawei.com>
-Günther Jungbluth <gunther@gameslabs.net>
-Hakan Özler <hakan.ozler@kodcu.com>
-Hao Zhang <21521210@zju.edu.cn>
-Harald Albers <github@albersweb.de>
-Harold Cooper <hrldcpr@gmail.com>
-Harry Zhang <harryz@hyper.sh>
-He Simei <hesimei@zju.edu.cn>
-Helen Xie <chenjg@harmonycloud.cn>
-Henning Sprang <henning.sprang@gmail.com>
-Hernan Garcia <hernandanielg@gmail.com>
-Hongbin Lu <hongbin034@gmail.com>
-Hu Keping <hukeping@huawei.com>
-Huayi Zhang <irachex@gmail.com>
-huqun <huqun@zju.edu.cn>
-Huu Nguyen <huu@prismskylabs.com>
-Hyzhou Zhy <hyzhou.zhy@alibaba-inc.com>
-Ian Campbell <ian.campbell@docker.com>
-Ian Philpot <ian.philpot@microsoft.com>
-Ignacio Capurro <icapurrofagian@gmail.com>
-Ilya Dmitrichenko <errordeveloper@gmail.com>
-Ilya Khlopotov <ilya.khlopotov@gmail.com>
-Ilya Sotkov <ilya@sotkov.com>
-Isabel Jimenez <contact.isabeljimenez@gmail.com>
-Ivan Grcic <igrcic@gmail.com>
-Ivan Markin <sw@nogoegst.net>
-Jacob Atzen <jacob@jacobatzen.dk>
-Jacob Tomlinson <jacob@tom.linson.uk>
-Jaivish Kothari <janonymous.codevulture@gmail.com>
-Jake Sanders <jsand@google.com>
-James Nesbitt <james.nesbitt@wunderkraut.com>
-James Turnbull <james@lovedthanlost.net>
-Jamie Hannaford <jamie@limetree.org>
-Jan Koprowski <jan.koprowski@gmail.com>
-Jan Pazdziora <jpazdziora@redhat.com>
-Jan-Jaap Driessen <janjaapdriessen@gmail.com>
-Jana Radhakrishnan <mrjana@docker.com>
-Jared Hocutt <jaredh@netapp.com>
-Jasmine Hegman <jasmine@jhegman.com>
-Jason Heiss <jheiss@aput.net>
-Jason Plum <jplum@devonit.com>
-Jay Kamat <github@jgkamat.33mail.com>
-Jean-Pierre Huynh <jean-pierre.huynh@ounet.fr>
-Jean-Pierre Huynh <jp@moogsoft.com>
-Jeff Lindsay <progrium@gmail.com>
-Jeff Nickoloff <jeff.nickoloff@gmail.com>
-Jeff Silberman <jsilberm@gmail.com>
-Jeremy Chambers <jeremy@thehipbot.com>
-Jeremy Unruh <jeremybunruh@gmail.com>
-Jeremy Yallop <yallop@docker.com>
-Jeroen Franse <jeroenfranse@gmail.com>
-Jesse Adametz <jesseadametz@gmail.com>
-Jessica Frazelle <jessfraz@google.com>
-Jezeniel Zapanta <jpzapanta22@gmail.com>
-Jian Zhang <zhangjian.fnst@cn.fujitsu.com>
-Jie Luo <luo612@zju.edu.cn>
-Jilles Oldenbeuving <ojilles@gmail.com>
-Jim Galasyn <jim.galasyn@docker.com>
-Jimmy Leger <jimmy.leger@gmail.com>
-Jimmy Song <rootsongjc@gmail.com>
-jimmyxian <jimmyxian2004@yahoo.com.cn>
-Joao Fernandes <joao.fernandes@docker.com>
-Joe Doliner <jdoliner@pachyderm.io>
-Joe Gordon <joe.gordon0@gmail.com>
-Joel Handwell <joelhandwell@gmail.com>
-Joey Geiger <jgeiger@gmail.com>
-Joffrey F <joffrey@docker.com>
-Johan Euphrosine <proppy@google.com>
-Johannes 'fish' Ziemke <github@freigeist.org>
-John Feminella <jxf@jxf.me>
-John Harris <john@johnharris.io>
-John Howard (VM) <John.Howard@microsoft.com>
-John Laswell <john.n.laswell@gmail.com>
-John Maguire <jmaguire@duosecurity.com>
-John Mulhausen <john@docker.com>
-John Starks <jostarks@microsoft.com>
-John Stephens <johnstep@docker.com>
-John Tims <john.k.tims@gmail.com>
-John V. Martinez <jvmatl@gmail.com>
-John Willis <john.willis@docker.com>
-Jonathan Boulle <jonathanboulle@gmail.com>
-Jonathan Lee <jonjohn1232009@gmail.com>
-Jonathan Lomas <jonathan@floatinglomas.ca>
-Jonathan McCrohan <jmccrohan@gmail.com>
-Jonh Wendell <jonh.wendell@redhat.com>
-Jordan Jennings <jjn2009@gmail.com>
-Joseph Kern <jkern@semafour.net>
-Josh Bodah <jb3689@yahoo.com>
-Josh Chorlton <jchorlton@gmail.com>
-Josh Hawn <josh.hawn@docker.com>
-Josh Horwitz <horwitz@addthis.com>
-Josh Soref <jsoref@gmail.com>
-Julien Barbier <write0@gmail.com>
-Julien Kassar <github@kassisol.com>
-Julien Maitrehenry <julien.maitrehenry@me.com>
-Justas Brazauskas <brazauskasjustas@gmail.com>
-Justin Cormack <justin.cormack@docker.com>
-Justin Simonelis <justin.p.simonelis@gmail.com>
-Jyrki Puttonen <jyrkiput@gmail.com>
-Jérôme Petazzoni <jerome.petazzoni@docker.com>
-Jörg Thalheim <joerg@higgsboson.tk>
-Kai Blin <kai@samba.org>
-Kai Qiang Wu (Kennan) <wkq5325@gmail.com>
-Kara Alexandra <kalexandra@us.ibm.com>
-Kareem Khazem <karkhaz@karkhaz.com>
-Karthik Nayak <Karthik.188@gmail.com>
-Kat Samperi <kat.samperi@gmail.com>
-Katie McLaughlin <katie@glasnt.com>
-Ke Xu <leonhartx.k@gmail.com>
-Kei Ohmura <ohmura.kei@gmail.com>
-Keith Hudgins <greenman@greenman.org>
-Ken Cochrane <kencochrane@gmail.com>
-Ken ICHIKAWA <ichikawa.ken@jp.fujitsu.com>
-Kenfe-Mickaël Laventure <mickael.laventure@gmail.com>
-Kevin Burke <kev@inburke.com>
-Kevin Feyrer <kevin.feyrer@btinternet.com>
-Kevin Kern <kaiwentan@harmonycloud.cn>
-Kevin Meredith <kevin.m.meredith@gmail.com>
-Kevin Richardson <kevin@kevinrichardson.co>
-khaled souf <khaled.souf@gmail.com>
-Kim Eik <kim@heldig.org>
-Kir Kolyshkin <kolyshkin@gmail.com>
-Kotaro Yoshimatsu <kotaro.yoshimatsu@gmail.com>
-Krasi Georgiev <krasi@vip-consult.solutions>
-Kris-Mikael Krister <krismikael@protonmail.com>
-Kun Zhang <zkazure@gmail.com>
-Kunal Kushwaha <kushwaha_kunal_v7@lab.ntt.co.jp>
-Kyle Spiers <kyle@spiers.me>
-Lachlan Cooper <lachlancooper@gmail.com>
-Lai Jiangshan <jiangshanlai@gmail.com>
-Lars Kellogg-Stedman <lars@redhat.com>
-Laura Frank <ljfrank@gmail.com>
-Laurent Erignoux <lerignoux@gmail.com>
-Lei Jitang <leijitang@huawei.com>
-Lennie <github@consolejunkie.net>
-Leo Gallucci <elgalu3@gmail.com>
-Lewis Daly <lewisdaly@me.com>
-Li Yi <denverdino@gmail.com>
-Li Yi <weiyuan.yl@alibaba-inc.com>
-Liang-Chi Hsieh <viirya@gmail.com>
-Lily Guo <lily.guo@docker.com>
-Lin Lu <doraalin@163.com>
-Linus Heckemann <lheckemann@twig-world.com>
-Liping Xue <lipingxue@gmail.com>
-Liron Levin <liron@twistlock.com>
-liwenqi <vikilwq@zju.edu.cn>
-lixiaobing10051267 <li.xiaobing1@zte.com.cn>
-Lloyd Dewolf <foolswisdom@gmail.com>
-Lorenzo Fontana <lo@linux.com>
-Louis Opter <kalessin@kalessin.fr>
-Luca Favatella <luca.favatella@erlang-solutions.com>
-Luca Marturana <lucamarturana@gmail.com>
-Lucas Chan <lucas-github@lucaschan.com>
-Luka Hartwig <mail@lukahartwig.de>
-Lukasz Zajaczkowski <Lukasz.Zajaczkowski@ts.fujitsu.com>
-Lénaïc Huard <lhuard@amadeus.com>
-Ma Shimiao <mashimiao.fnst@cn.fujitsu.com>
-Mabin <bin.ma@huawei.com>
-Madhav Puri <madhav.puri@gmail.com>
-Madhu Venugopal <madhu@socketplane.io>
-Malte Janduda <mail@janduda.net>
-Manjunath A Kumatagi <mkumatag@in.ibm.com>
-Mansi Nahar <mmn4185@rit.edu>
-mapk0y <mapk0y@gmail.com>
-Marc Bihlmaier <marc.bihlmaier@reddoxx.com>
-Marco Mariani <marco.mariani@alterway.fr>
-Marcus Martins <marcus@docker.com>
-Marianna Tessel <mtesselh@gmail.com>
-Marius Sturm <marius@graylog.com>
-Mark Oates <fl0yd@me.com>
-Martin Mosegaard Amdisen <martin.amdisen@praqma.com>
-Mary Anthony <mary.anthony@docker.com>
-Mason Malone <mason.malone@gmail.com>
-Mateusz Major <apkd@users.noreply.github.com>
-Matt Gucci <matt9ucci@gmail.com>
-Matt Robenolt <matt@ydekproductions.com>
-Matthew Heon <mheon@redhat.com>
-Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
-Max Shytikov <mshytikov@gmail.com>
-Maxime Petazzoni <max@signalfuse.com>
-Mei ChunTao <mei.chuntao@zte.com.cn>
-Micah Zoltu <micah@newrelic.com>
-Michael A. Smith <michael@smith-li.com>
-Michael Bridgen <mikeb@squaremobius.net>
-Michael Crosby <michael@docker.com>
-Michael Friis <friism@gmail.com>
-Michael Irwin <mikesir87@gmail.com>
-Michael Käufl <docker@c.michael-kaeufl.de>
-Michael Prokop <github@michael-prokop.at>
-Michael Scharf <github@scharf.gr>
-Michael Spetsiotis <michael_spets@hotmail.com>
-Michael Steinert <mike.steinert@gmail.com>
-Michael West <mwest@mdsol.com>
-Michal Minář <miminar@redhat.com>
-Michał Czeraszkiewicz <czerasz@gmail.com>
-Miguel Angel Alvarez Cabrerizo <doncicuto@gmail.com>
-Mihai Borobocea <MihaiBorob@gmail.com>
-Mihuleacc Sergiu <mihuleac.sergiu@gmail.com>
-Mike Brown <brownwm@us.ibm.com>
-Mike Casas <mkcsas0@gmail.com>
-Mike Danese <mikedanese@google.com>
-Mike Dillon <mike@embody.org>
-Mike Goelzer <mike.goelzer@docker.com>
-Mike MacCana <mike.maccana@gmail.com>
-mikelinjie <294893458@qq.com>
-Mikhail Vasin <vasin@cloud-tv.ru>
-Milind Chawre <milindchawre@gmail.com>
-Misty Stanley-Jones <misty@docker.com>
-Mohammad Banikazemi <mb@us.ibm.com>
-Mohammed Aaqib Ansari <maaquib@gmail.com>
-Moorthy RS <rsmoorthy@gmail.com>
-Morgan Bauer <mbauer@us.ibm.com>
-Moysés Borges <moysesb@gmail.com>
-Mrunal Patel <mrunalp@gmail.com>
-muicoder <muicoder@gmail.com>
-Muthukumar R <muthur@gmail.com>
-Máximo Cuadros <mcuadros@gmail.com>
-Nace Oroz <orkica@gmail.com>
-Nahum Shalman <nshalman@omniti.com>
-Nalin Dahyabhai <nalin@redhat.com>
-Natalie Parker <nparker@omnifone.com>
-Nate Brennand <nate.brennand@clever.com>
-Nathan Hsieh <hsieh.nathan@gmail.com>
-Nathan LeClaire <nathan.leclaire@docker.com>
-Nathan McCauley <nathan.mccauley@docker.com>
-Neil Peterson <neilpeterson@outlook.com>
-Nicola Kabar <nicolaka@gmail.com>
-Nicolas Borboën <ponsfrilus@gmail.com>
-Nicolas De Loof <nicolas.deloof@gmail.com>
-Nikhil Chawla <chawlanikhil24@gmail.com>
-Nikolas Garofil <nikolas.garofil@uantwerpen.be>
-Nikolay Milovanov <nmil@itransformers.net>
-Nishant Totla <nishanttotla@gmail.com>
-NIWA Hideyuki <niwa.niwa@nifty.ne.jp>
-Noah Treuhaft <noah.treuhaft@docker.com>
-O.S. Tezer <ostezer@gmail.com>
-ohmystack <jun.jiang02@ele.me>
-Olle Jonsson <olle.jonsson@gmail.com>
-Otto Kekäläinen <otto@seravo.fi>
-Ovidio Mallo <ovidio.mallo@gmail.com>
-Pascal Borreli <pascal@borreli.com>
-Patrick Böänziger <patrick.baenziger@bsi-software.com>
-Patrick Hemmer <patrick.hemmer@gmail.com>
-Patrick Lang <plang@microsoft.com>
-Paul <paul9869@gmail.com>
-Paul Kehrer <paul.l.kehrer@gmail.com>
-Paul Lietar <paul@lietar.net>
-Paul Weaver <pauweave@cisco.com>
-Pavel Pospisil <pospispa@gmail.com>
-Paweł Szczekutowicz <pszczekutowicz@gmail.com>
-Peeyush Gupta <gpeeyush@linux.vnet.ibm.com>
-Peter Edge <peter.edge@gmail.com>
-Peter Jaffe <pjaffe@nevo.com>
-Peter Nagy <xificurC@gmail.com>
-Peter Salvatore <peter@psftw.com>
-Peter Waller <p@pwaller.net>
-Phil Estes <estesp@linux.vnet.ibm.com>
-Philip Alexander Etling <paetling@gmail.com>
-Philipp Gillé <philipp.gille@gmail.com>
-pidster <pid@pidster.com>
-pixelistik <pixelistik@users.noreply.github.com>
-Pratik Karki <prertik@outlook.com>
-Prayag Verma <prayag.verma@gmail.com>
-Pure White <daniel48@126.com>
-Qiang Huang <h.huangqiang@huawei.com>
-Qinglan Peng <qinglanpeng@zju.edu.cn>
-qudongfang <qudongfang@gmail.com>
-Raghavendra K T <raghavendra.kt@linux.vnet.ibm.com>
-Ray Tsang <rayt@google.com>
-Reficul <xuzhenglun@gmail.com>
-Remy Suen <remy.suen@gmail.com>
-Renaud Gaubert <rgaubert@nvidia.com>
-Ricardo N Feliciano <FelicianoTech@gmail.com>
-Rich Moyse <rich@moyse.us>
-Richard Mathie <richard.mathie@amey.co.uk>
-Richard Scothern <richard.scothern@gmail.com>
-Rick Wieman <git@rickw.nl>
-Ritesh H Shukla <sritesh@vmware.com>
-Riyaz Faizullabhoy <riyaz.faizullabhoy@docker.com>
-Robert Wallis <smilingrob@gmail.com>
-Robin Naundorf <r.naundorf@fh-muenster.de>
-Robin Speekenbrink <robin@kingsquare.nl>
-Rodolfo Ortiz <rodolfo.ortiz@definityfirst.com>
-Rogelio Canedo <rcanedo@mappy.priv>
-Roland Kammerer <roland.kammerer@linbit.com>
-Roman Dudin <katrmr@gmail.com>
-Rory Hunter <roryhunter2@gmail.com>
-Ross Boucher <rboucher@gmail.com>
-Rubens Figueiredo <r.figueiredo.52@gmail.com>
-Ryan Belgrave <rmb1993@gmail.com>
-Ryan Detzel <ryan.detzel@gmail.com>
-Ryan Stelly <ryan.stelly@live.com>
-Sainath Grandhi <sainath.grandhi@intel.com>
-Sakeven Jiang <jc5930@sina.cn>
-Sally O'Malley <somalley@redhat.com>
-Sam Neirinck <sam@samneirinck.com>
-Sambuddha Basu <sambuddhabasu1@gmail.com>
-Samuel Karp <skarp@amazon.com>
-Santhosh Manohar <santhosh@docker.com>
-Scott Collier <emailscottcollier@gmail.com>
-Sean Christopherson <sean.j.christopherson@intel.com>
-Sean Rodman <srodman7689@gmail.com>
-Sebastiaan van Stijn <github@gone.nl>
-Sergey Tryuber <Sergeant007@users.noreply.github.com>
-Serhat Gülçiçek <serhat25@gmail.com>
-Sevki Hasirci <s@sevki.org>
-Shaun Kaasten <shaunk@gmail.com>
-Sheng Yang <sheng@yasker.org>
-Shijiang Wei <mountkin@gmail.com>
-Shishir Mahajan <shishir.mahajan@redhat.com>
-Shoubhik Bose <sbose78@gmail.com>
-Shukui Yang <yangshukui@huawei.com>
-Sian Lerk Lau <kiawin@gmail.com>
-Sidhartha Mani <sidharthamn@gmail.com>
-sidharthamani <sid@rancher.com>
-Silvin Lubecki <silvin.lubecki@docker.com>
-Simei He <hesimei@zju.edu.cn>
-Simon Ferquel <simon.ferquel@docker.com>
-Sindhu S <sindhus@live.in>
-Slava Semushin <semushin@redhat.com>
-Solomon Hykes <solomon@docker.com>
-Song Gao <song@gao.io>
-Spencer Brown <spencer@spencerbrown.org>
-squeegels <1674195+squeegels@users.noreply.github.com>
-Srini Brahmaroutu <srbrahma@us.ibm.com>
-Stefan S. <tronicum@user.github.com>
-Stefan Scherer <scherer_stefan@icloud.com>
-Stefan Weil <sw@weilnetz.de>
-Stephen Day <stephen.day@docker.com>
-Stephen Rust <srust@blockbridge.com>
-Steve Durrheimer <s.durrheimer@gmail.com>
-Steven Burgess <steven.a.burgess@hotmail.com>
-Subhajit Ghosh <isubuz.g@gmail.com>
-Sun Jianbo <wonderflow.sun@gmail.com>
-Sungwon Han <sungwon.han@navercorp.com>
-Sven Dowideit <SvenDowideit@home.org.au>
-Sylvain Baubeau <sbaubeau@redhat.com>
-Sébastien HOUZÉ <cto@verylastroom.com>
-T K Sourabh <sourabhtk37@gmail.com>
-TAGOMORI Satoshi <tagomoris@gmail.com>
-Taylor Jones <monitorjbl@gmail.com>
-Thatcher Peskens <thatcher@docker.com>
-Thomas Gazagnaire <thomas@gazagnaire.org>
-Thomas Krzero <thomas.kovatchitch@gmail.com>
-Thomas Leonard <thomas.leonard@docker.com>
-Thomas Léveil <thomasleveil@gmail.com>
-Thomas Riccardi <riccardi@systran.fr>
-Thomas Swift <tgs242@gmail.com>
-Tianon Gravi <admwiggin@gmail.com>
-Tianyi Wang <capkurmagati@gmail.com>
-Tibor Vass <teabee89@gmail.com>
-Tim Dettrick <t.dettrick@uq.edu.au>
-Tim Hockin <thockin@google.com>
-Tim Smith <timbot@google.com>
-Tim Waugh <twaugh@redhat.com>
-Tim Wraight <tim.wraight@tangentlabs.co.uk>
-timfeirg <kkcocogogo@gmail.com>
-Timothy Hobbs <timothyhobbs@seznam.cz>
-Tobias Bradtke <webwurst@gmail.com>
-Tobias Gesellchen <tobias@gesellix.de>
-Todd Whiteman <todd.whiteman@joyent.com>
-Tom Denham <tom@tomdee.co.uk>
-Tom Fotherby <tom+github@peopleperhour.com>
-Tom X. Tobin <tomxtobin@tomxtobin.com>
-Tomas Tomecek <ttomecek@redhat.com>
-Tomasz Kopczynski <tomek@kopczynski.net.pl>
-Tomáš Hrčka <thrcka@redhat.com>
-Tony Abboud <tdabboud@hotmail.com>
-Tõnis Tiigi <tonistiigi@gmail.com>
-Trapier Marshall <trapier.marshall@docker.com>
-Travis Cline <travis.cline@gmail.com>
-Tristan Carel <tristan@cogniteev.com>
-Tycho Andersen <tycho@docker.com>
-Tycho Andersen <tycho@tycho.ws>
-uhayate <uhayate.gong@daocloud.io>
-Umesh Yadav <umesh4257@gmail.com>
-Valentin Lorentz <progval+git@progval.net>
-Veres Lajos <vlajos@gmail.com>
-Victor Vieux <victor.vieux@docker.com>
-Victoria Bialas <victoria.bialas@docker.com>
-Viktor Stanchev <me@viktorstanchev.com>
-Vincent Batts <vbatts@redhat.com>
-Vincent Bernat <Vincent.Bernat@exoscale.ch>
-Vincent Demeester <vincent.demeester@docker.com>
-Vincent Woo <me@vincentwoo.com>
-Vishnu Kannan <vishnuk@google.com>
-Vivek Goyal <vgoyal@redhat.com>
-Wang Jie <wangjie5@chinaskycloud.com>
-Wang Long <long.wanglong@huawei.com>
-Wang Ping <present.wp@icloud.com>
-Wang Xing <hzwangxing@corp.netease.com>
-Wang Yuexiao <wang.yuexiao@zte.com.cn>
-Wataru Ishida <ishida.wataru@lab.ntt.co.jp>
-Wayne Song <wsong@docker.com>
-Wen Cheng Ma <wenchma@cn.ibm.com>
-Wenzhi Liang <wenzhi.liang@gmail.com>
-Wes Morgan <cap10morgan@gmail.com>
-Wewang Xiaorenfine <wang.xiaoren@zte.com.cn>
-William Henry <whenry@redhat.com>
-Xianglin Gao <xlgao@zju.edu.cn>
-Xinbo Weng <xihuanbo_0521@zju.edu.cn>
-Xuecong Liao <satorulogic@gmail.com>
-Yan Feng <yanfeng2@huawei.com>
-Yanqiang Miao <miao.yanqiang@zte.com.cn>
-Yassine Tijani <yasstij11@gmail.com>
-Yi EungJun <eungjun.yi@navercorp.com>
-Ying Li <ying.li@docker.com>
-Yong Tang <yong.tang.github@outlook.com>
-Yosef Fertel <yfertel@gmail.com>
-Yu Peng <yu.peng36@zte.com.cn>
-Yuan Sun <sunyuan3@huawei.com>
-Yunxiang Huang <hyxqshk@vip.qq.com>
-zebrilee <zebrilee@gmail.com>
-Zhang Kun <zkazure@gmail.com>
-Zhang Wei <zhangwei555@huawei.com>
-Zhang Wentao <zhangwentao234@huawei.com>
-ZhangHang <stevezhang2014@gmail.com>
-zhenghenghuo <zhenghenghuo@zju.edu.cn>
-Zhou Hao <zhouhao@cn.fujitsu.com>
-Zhu Guihua <zhugh.fnst@cn.fujitsu.com>
-Álex González <agonzalezro@gmail.com>
-Álvaro Lázaro <alvaro.lazaro.g@gmail.com>
-Átila Camurça Alves <camurca.home@gmail.com>
-徐俊杰 <paco.xu@daocloud.io>

components/cli/MAINTAINERS

@@ -1,6 +1,6 @@
 # Docker maintainers file
 #
-# This file describes who runs the docker/cli project and how.
+# This file describes who runs the docker/docker project and how.
 # This is a living document - if you see something out of date or missing, speak up!
 #
 # It is structured to be consumable by both humans and programs.
@@ -21,12 +21,23 @@
 	# a subsystem, they are responsible for doing so and holding the
 	# subsystem maintainers accountable. If ownership is unclear, they are the de facto owners.
 
+	# For each release (including minor releases), a "release captain" is assigned from the
+	# pool of core maintainers. Rotation is encouraged across all maintainers, to ensure
+	# the release process is clear and up-to-date.
+
 		people = [
 			"aaronlehmann",
 			"albers",
+			"aluzzardi",
+			"anusha",
 			"cpuguy83",
+			"crosbymichael",
 			"dnephin",
+			"ehazlett",
+			"johnstep",
 			"justincormack",
+			"mavenugo",
+			"mlaventure",
 			"stevvooe",
 			"tibor",
 			"tonistiigi",
@@ -56,6 +67,7 @@
 	# - close an issue or pull request when it's inappropriate or off-topic
 
 		people = [
+			"ehazlett",
 			"programmerq",
 			"thajeztah"
 		]
@@ -78,16 +90,41 @@
 	Email = "github@albersweb.de"
 	GitHub = "albers"
 
+	[people.aluzzardi]
+	Name = "Andrea Luzzardi"
+	Email = "al@docker.com"
+	GitHub = "aluzzardi"
+
+	[people.anusha]
+	Name = "Anusha Ragunathan"
+	Email = "anusha@docker.com"
+	GitHub = "anusha-ragunathan"
+
 	[people.cpuguy83]
 	Name = "Brian Goff"
 	Email = "cpuguy83@gmail.com"
 	GitHub = "cpuguy83"
 
+	[people.crosbymichael]
+	Name = "Michael Crosby"
+	Email = "crosbymichael@gmail.com"
+	GitHub = "crosbymichael"
+
 	[people.dnephin]
 	Name = "Daniel Nephin"
 	Email = "dnephin@gmail.com"
 	GitHub = "dnephin"
 
+	[people.ehazlett]
+	Name = "Evan Hazlett"
+	Email = "ejhazlett@gmail.com"
+	GitHub = "ehazlett"
+
+	[people.johnstep]
+	Name = "John Stephens"
+	Email = "johnstep@docker.com"
+	GitHub = "johnstep"
+
 	[people.justincormack]
 	Name = "Justin Cormack"
 	Email = "justin.cormack@docker.com"
@@ -98,10 +135,15 @@
 	Email = "misty@docker.com"
 	GitHub = "mistyhacks"
 
-	[people.programmerq]
-	Name = "Jeff Anderson"
-	Email = "jeff@docker.com"
-	GitHub = "programmerq"
+	[people.mlaventure]
+	Name = "Kenfe-Mickaël Laventure"
+	Email = "mickael.laventure@docker.com"
+	GitHub = "mlaventure"
+
+	[people.shykes]
+	Name = "Solomon Hykes"
+	Email = "solomon@docker.com"
+	GitHub = "shykes"
 
 	[people.stevvooe]
 	Name = "Stephen Day"

components/cli/Makefile

@@ -51,14 +51,9 @@ watch: ## monitor file changes and run go test
 	./scripts/test/watch
 
 vendor: vendor.conf ## check that vendor matches vendor.conf
-	rm -rf vendor
-	bash -c 'vndr |& grep -v -i clone'
+	vndr 2> /dev/null
 	scripts/validate/check-git-diff vendor
 
-.PHONY: authors
-authors: ## generate AUTHORS file from git history
-	scripts/docs/generate-authors.sh
-
 .PHONY: manpages
 manpages: ## generate man pages from go source and markdown
 	scripts/docs/generate-man.sh

components/cli/VERSION

@@ -1 +1 @@
-18.03.1-ce-rc2
+17.12.1-ce-rc2

components/cli/appveyor.yml

@@ -1,23 +0,0 @@
-version: "{build}"
-
-clone_folder: c:\gopath\src\github.com\docker\cli
-
-environment:
-  GOPATH: c:\gopath
-  GOVERSION: 1.10
-  DEPVERSION: v0.4.1
-
-install:
-  - rmdir c:\go /s /q
-  - appveyor DownloadFile https://storage.googleapis.com/golang/go%GOVERSION%.windows-amd64.msi
-  - msiexec /i go%GOVERSION%.windows-amd64.msi /q
-  - go version
-  - go env
-
-deploy: false
-
-build_script:
-  - ps: .\scripts\make.ps1 -Binary
-
-test_script:
-  - ps: .\scripts\make.ps1 -TestUnit

components/cli/cli/command/bundlefile/bundlefile_test.go

@@ -5,8 +5,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLoadFileV01Success(t *testing.T) {
@@ -26,9 +25,9 @@ func TestLoadFileV01Success(t *testing.T) {
 	}`)
 
 	bundle, err := LoadFile(reader)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal("0.1", bundle.Version))
-	assert.Check(t, is.Len(bundle.Services, 2))
+	assert.NoError(t, err)
+	assert.Equal(t, "0.1", bundle.Version)
+	assert.Len(t, bundle.Services, 2)
 }
 
 func TestLoadFileSyntaxError(t *testing.T) {
@@ -38,7 +37,7 @@ func TestLoadFileSyntaxError(t *testing.T) {
 	}`)
 
 	_, err := LoadFile(reader)
-	assert.Error(t, err, "JSON syntax error at byte 37: invalid character 'u' looking for beginning of value")
+	assert.EqualError(t, err, "JSON syntax error at byte 37: invalid character 'u' looking for beginning of value")
 }
 
 func TestLoadFileTypeError(t *testing.T) {
@@ -53,7 +52,7 @@ func TestLoadFileTypeError(t *testing.T) {
 	}`)
 
 	_, err := LoadFile(reader)
-	assert.Error(t, err, "Unexpected type at byte 94. Expected []string but received string.")
+	assert.EqualError(t, err, "Unexpected type at byte 94. Expected []string but received string.")
 }
 
 func TestPrint(t *testing.T) {
@@ -67,12 +66,12 @@ func TestPrint(t *testing.T) {
 			},
 		},
 	}
-	assert.Check(t, Print(&buffer, bundle))
+	assert.NoError(t, Print(&buffer, bundle))
 	output := buffer.String()
-	assert.Check(t, is.Contains(output, "\"Image\": \"image\""))
-	assert.Check(t, is.Contains(output,
+	assert.Contains(t, output, "\"Image\": \"image\"")
+	assert.Contains(t, output,
 		`"Command": [
                 "echo",
                 "something"
-            ]`))
+            ]`)
 }

components/cli/cli/command/checkpoint/create_test.go

@@ -6,10 +6,10 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCheckpointCreateErrors(t *testing.T) {
@@ -42,7 +42,7 @@ func TestCheckpointCreateErrors(t *testing.T) {
 		cmd := newCreateCommand(cli)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -63,10 +63,10 @@ func TestCheckpointCreateWithOptions(t *testing.T) {
 	cmd.SetArgs([]string{"container-foo", checkpoint})
 	cmd.Flags().Set("leave-running", "true")
 	cmd.Flags().Set("checkpoint-dir", "/dir/foo")
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("container-foo", containerID))
-	assert.Check(t, is.Equal(checkpoint, checkpointID))
-	assert.Check(t, is.Equal("/dir/foo", checkpointDir))
-	assert.Check(t, is.Equal(false, exit))
-	assert.Check(t, is.Equal(checkpoint, strings.TrimSpace(cli.OutBuffer().String())))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "container-foo", containerID)
+	assert.Equal(t, checkpoint, checkpointID)
+	assert.Equal(t, "/dir/foo", checkpointDir)
+	assert.Equal(t, false, exit)
+	assert.Equal(t, checkpoint, strings.TrimSpace(cli.OutBuffer().String()))
 }

components/cli/cli/command/checkpoint/list_test.go

@@ -5,11 +5,11 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCheckpointListErrors(t *testing.T) {
@@ -42,7 +42,7 @@ func TestCheckpointListErrors(t *testing.T) {
 		cmd := newListCommand(cli)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -60,8 +60,8 @@ func TestCheckpointListWithOptions(t *testing.T) {
 	cmd := newListCommand(cli)
 	cmd.SetArgs([]string{"container-foo"})
 	cmd.Flags().Set("checkpoint-dir", "/dir/foo")
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("container-foo", containerID))
-	assert.Check(t, is.Equal("/dir/foo", checkpointDir))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "container-foo", containerID)
+	assert.Equal(t, "/dir/foo", checkpointDir)
 	golden.Assert(t, cli.OutBuffer().String(), "checkpoint-list-with-options.golden")
 }

components/cli/cli/command/checkpoint/remove_test.go

@@ -5,10 +5,10 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCheckpointRemoveErrors(t *testing.T) {
@@ -41,7 +41,7 @@ func TestCheckpointRemoveErrors(t *testing.T) {
 		cmd := newRemoveCommand(cli)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -58,8 +58,8 @@ func TestCheckpointRemoveWithOptions(t *testing.T) {
 	cmd := newRemoveCommand(cli)
 	cmd.SetArgs([]string{"container-foo", "checkpoint-bar"})
 	cmd.Flags().Set("checkpoint-dir", "/dir/foo")
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("container-foo", containerID))
-	assert.Check(t, is.Equal("checkpoint-bar", checkpointID))
-	assert.Check(t, is.Equal("/dir/foo", checkpointDir))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "container-foo", containerID)
+	assert.Equal(t, "checkpoint-bar", checkpointID)
+	assert.Equal(t, "/dir/foo", checkpointDir)
 }

components/cli/cli/command/cli.go

@@ -5,23 +5,18 @@ import (
 	"net"
 	"net/http"
 	"os"
-	"path/filepath"
 	"runtime"
 	"time"
 
 	"github.com/docker/cli/cli"
-	"github.com/docker/cli/cli/config"
 	cliconfig "github.com/docker/cli/cli/config"
 	"github.com/docker/cli/cli/config/configfile"
 	cliflags "github.com/docker/cli/cli/flags"
-	manifeststore "github.com/docker/cli/cli/manifest/store"
-	registryclient "github.com/docker/cli/cli/registry/client"
 	"github.com/docker/cli/cli/trust"
 	dopts "github.com/docker/cli/opts"
 	"github.com/docker/docker/api"
-	"github.com/docker/docker/api/types"
-	registrytypes "github.com/docker/docker/api/types/registry"
 	"github.com/docker/docker/client"
+	"github.com/docker/go-connections/sockets"
 	"github.com/docker/go-connections/tlsconfig"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
@@ -47,30 +42,24 @@ type Cli interface {
 	SetIn(in *InStream)
 	ConfigFile() *configfile.ConfigFile
 	ServerInfo() ServerInfo
-	ClientInfo() ClientInfo
 	NotaryClient(imgRefAndAuth trust.ImageRefAndAuth, actions []string) (notaryclient.Repository, error)
-	DefaultVersion() string
-	ManifestStore() manifeststore.Store
-	RegistryClient(bool) registryclient.RegistryClient
-	ContentTrustEnabled() bool
 }
 
 // DockerCli is an instance the docker command line client.
 // Instances of the client can be returned from NewDockerCli.
 type DockerCli struct {
-	configFile   *configfile.ConfigFile
-	in           *InStream
-	out          *OutStream
-	err          io.Writer
-	client       client.APIClient
-	serverInfo   ServerInfo
-	clientInfo   ClientInfo
-	contentTrust bool
+	configFile     *configfile.ConfigFile
+	in             *InStream
+	out            *OutStream
+	err            io.Writer
+	client         client.APIClient
+	defaultVersion string
+	server         ServerInfo
 }
 
 // DefaultVersion returns api.defaultVersion or DOCKER_API_VERSION if specified.
 func (cli *DockerCli) DefaultVersion() string {
-	return cli.clientInfo.DefaultVersion
+	return cli.defaultVersion
 }
 
 // Client returns the APIClient
@@ -115,33 +104,7 @@ func (cli *DockerCli) ConfigFile() *configfile.ConfigFile {
 // ServerInfo returns the server version details for the host this client is
 // connected to
 func (cli *DockerCli) ServerInfo() ServerInfo {
-	return cli.serverInfo
-}
-
-// ClientInfo returns the client details for the cli
-func (cli *DockerCli) ClientInfo() ClientInfo {
-	return cli.clientInfo
-}
-
-// ContentTrustEnabled returns whether content trust has been enabled by an
-// environment variable.
-func (cli *DockerCli) ContentTrustEnabled() bool {
-	return cli.contentTrust
-}
-
-// ManifestStore returns a store for local manifests
-func (cli *DockerCli) ManifestStore() manifeststore.Store {
-	// TODO: support override default location from config file
-	return manifeststore.NewStore(filepath.Join(config.Dir(), "manifests"))
-}
-
-// RegistryClient returns a client for communicating with a Docker distribution
-// registry
-func (cli *DockerCli) RegistryClient(allowInsecure bool) registryclient.RegistryClient {
-	resolver := func(ctx context.Context, index *registrytypes.IndexInfo) types.AuthConfig {
-		return ResolveAuthConfig(ctx, cli, index)
-	}
-	return registryclient.NewRegistryClient(resolver, UserAgent(), allowInsecure)
+	return cli.server
 }
 
 // Initialize the dockerCli runs initialization that must happen after command
@@ -162,36 +125,17 @@ func (cli *DockerCli) Initialize(opts *cliflags.ClientOptions) error {
 	if err != nil {
 		return err
 	}
-	hasExperimental, err := isEnabled(cli.configFile.Experimental)
-	if err != nil {
-		return errors.Wrap(err, "Experimental field")
-	}
-	orchestrator := GetOrchestrator(hasExperimental, opts.Common.Orchestrator, cli.configFile.Orchestrator)
-	cli.clientInfo = ClientInfo{
-		DefaultVersion:  cli.client.ClientVersion(),
-		HasExperimental: hasExperimental,
-		Orchestrator:    orchestrator,
-	}
 	cli.initializeFromClient()
 	return nil
 }
 
-func isEnabled(value string) (bool, error) {
-	switch value {
-	case "enabled":
-		return true, nil
-	case "", "disabled":
-		return false, nil
-	default:
-		return false, errors.Errorf("%q is not valid, should be either enabled or disabled", value)
-	}
-}
-
 func (cli *DockerCli) initializeFromClient() {
+	cli.defaultVersion = cli.client.ClientVersion()
+
 	ping, err := cli.client.Ping(context.Background())
 	if err != nil {
 		// Default to true if we fail to connect to daemon
-		cli.serverInfo = ServerInfo{HasExperimental: true}
+		cli.server = ServerInfo{HasExperimental: true}
 
 		if ping.APIVersion != "" {
 			cli.client.NegotiateAPIVersionPing(ping)
@@ -199,7 +143,7 @@ func (cli *DockerCli) initializeFromClient() {
 		return
 	}
 
-	cli.serverInfo = ServerInfo{
+	cli.server = ServerInfo{
 		HasExperimental: ping.Experimental,
 		OSType:          ping.OSType,
 	}
@@ -232,21 +176,9 @@ type ServerInfo struct {
 	OSType          string
 }
 
-// ClientInfo stores details about the supported features of the client
-type ClientInfo struct {
-	HasExperimental bool
-	DefaultVersion  string
-	Orchestrator    Orchestrator
-}
-
-// HasKubernetes checks if kubernetes orchestrator is enabled
-func (c ClientInfo) HasKubernetes() bool {
-	return c.HasExperimental && c.Orchestrator == OrchestratorKubernetes
-}
-
 // NewDockerCli returns a DockerCli instance with IO output and error streams set by in, out and err.
-func NewDockerCli(in io.ReadCloser, out, err io.Writer, isTrusted bool) *DockerCli {
-	return &DockerCli{in: NewInStream(in), out: NewOutStream(out), err: err, contentTrust: isTrusted}
+func NewDockerCli(in io.ReadCloser, out, err io.Writer) *DockerCli {
+	return &DockerCli{in: NewInStream(in), out: NewOutStream(out), err: err}
 }
 
 // NewAPIClientFromFlags creates a new APIClient from command line flags
@@ -267,12 +199,12 @@ func NewAPIClientFromFlags(opts *cliflags.CommonOptions, configFile *configfile.
 		verStr = tmpStr
 	}
 
-	return client.NewClientWithOpts(
-		withHTTPClient(opts.TLSOptions),
-		client.WithHTTPHeaders(customHeaders),
-		client.WithVersion(verStr),
-		client.WithHost(host),
-	)
+	httpClient, err := newHTTPClient(host, opts.TLSOptions)
+	if err != nil {
+		return &client.Client{}, err
+	}
+
+	return client.NewClient(host, verStr, httpClient, customHeaders)
 }
 
 func getServerHost(hosts []string, tlsOptions *tlsconfig.Options) (string, error) {
@@ -289,32 +221,35 @@ func getServerHost(hosts []string, tlsOptions *tlsconfig.Options) (string, error
 	return dopts.ParseHost(tlsOptions != nil, host)
 }
 
-func withHTTPClient(tlsOpts *tlsconfig.Options) func(*client.Client) error {
-	return func(c *client.Client) error {
-		if tlsOpts == nil {
-			// Use the default HTTPClient
-			return nil
-		}
-
-		opts := *tlsOpts
-		opts.ExclusiveRootPools = true
-		tlsConfig, err := tlsconfig.Client(opts)
-		if err != nil {
-			return err
-		}
-
-		httpClient := &http.Client{
-			Transport: &http.Transport{
-				TLSClientConfig: tlsConfig,
-				DialContext: (&net.Dialer{
-					KeepAlive: 30 * time.Second,
-					Timeout:   30 * time.Second,
-				}).DialContext,
-			},
-			CheckRedirect: client.CheckRedirect,
-		}
-		return client.WithHTTPClient(httpClient)(c)
+func newHTTPClient(host string, tlsOptions *tlsconfig.Options) (*http.Client, error) {
+	if tlsOptions == nil {
+		// let the api client configure the default transport.
+		return nil, nil
 	}
+	opts := *tlsOptions
+	opts.ExclusiveRootPools = true
+	config, err := tlsconfig.Client(opts)
+	if err != nil {
+		return nil, err
+	}
+	tr := &http.Transport{
+		TLSClientConfig: config,
+		DialContext: (&net.Dialer{
+			KeepAlive: 30 * time.Second,
+			Timeout:   30 * time.Second,
+		}).DialContext,
+	}
+	proto, addr, _, err := client.ParseHost(host)
+	if err != nil {
+		return nil, err
+	}
+
+	sockets.ConfigureTransport(tr, proto, addr)
+
+	return &http.Client{
+		Transport:     tr,
+		CheckRedirect: client.CheckRedirect,
+	}, nil
 }
 
 // UserAgent returns the user agent string used for making API requests

components/cli/cli/command/cli_test.go

@@ -1,29 +1,25 @@
 package command
 
 import (
-	"crypto/x509"
 	"os"
-	"runtime"
 	"testing"
 
-	cliconfig "github.com/docker/cli/cli/config"
+	"crypto/x509"
+
 	"github.com/docker/cli/cli/config/configfile"
 	"github.com/docker/cli/cli/flags"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/fs"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"golang.org/x/net/context"
 )
 
 func TestNewAPIClientFromFlags(t *testing.T) {
 	host := "unix://path"
-	if runtime.GOOS == "windows" {
-		host = "npipe://./"
-	}
 	opts := &flags.CommonOptions{Hosts: []string{host}}
 	configFile := &configfile.ConfigFile{
 		HTTPHeaders: map[string]string{
@@ -31,15 +27,15 @@ func TestNewAPIClientFromFlags(t *testing.T) {
 		},
 	}
 	apiclient, err := NewAPIClientFromFlags(opts, configFile)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(host, apiclient.DaemonHost()))
+	require.NoError(t, err)
+	assert.Equal(t, host, apiclient.DaemonHost())
 
 	expectedHeaders := map[string]string{
 		"My-Header":  "Custom-Value",
 		"User-Agent": UserAgent(),
 	}
-	assert.Check(t, is.DeepEqual(expectedHeaders, apiclient.(*client.Client).CustomHTTPHeaders()))
-	assert.Check(t, is.Equal(api.DefaultVersion, apiclient.ClientVersion()))
+	assert.Equal(t, expectedHeaders, apiclient.(*client.Client).CustomHTTPHeaders())
+	assert.Equal(t, api.DefaultVersion, apiclient.ClientVersion())
 }
 
 func TestNewAPIClientFromFlagsWithAPIVersionFromEnv(t *testing.T) {
@@ -49,20 +45,20 @@ func TestNewAPIClientFromFlagsWithAPIVersionFromEnv(t *testing.T) {
 	opts := &flags.CommonOptions{}
 	configFile := &configfile.ConfigFile{}
 	apiclient, err := NewAPIClientFromFlags(opts, configFile)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(customVersion, apiclient.ClientVersion()))
+	require.NoError(t, err)
+	assert.Equal(t, customVersion, apiclient.ClientVersion())
 }
 
 // TODO: use gotestyourself/env.Patch
 func patchEnvVariable(t *testing.T, key, value string) func() {
 	oldValue, ok := os.LookupEnv(key)
-	assert.NilError(t, os.Setenv(key, value))
+	require.NoError(t, os.Setenv(key, value))
 	return func() {
 		if !ok {
-			assert.NilError(t, os.Unsetenv(key))
+			require.NoError(t, os.Unsetenv(key))
 			return
 		}
-		assert.NilError(t, os.Setenv(key, oldValue))
+		require.NoError(t, os.Setenv(key, oldValue))
 	}
 }
 
@@ -128,151 +124,9 @@ func TestInitializeFromClient(t *testing.T) {
 
 			cli := &DockerCli{client: apiclient}
 			cli.initializeFromClient()
-			assert.Check(t, is.DeepEqual(testcase.expectedServer, cli.serverInfo))
-			assert.Check(t, is.Equal(testcase.negotiated, apiclient.negotiated))
-		})
-	}
-}
-
-func TestExperimentalCLI(t *testing.T) {
-	defaultVersion := "v1.55"
-
-	var testcases = []struct {
-		doc                     string
-		configfile              string
-		expectedExperimentalCLI bool
-	}{
-		{
-			doc:                     "default",
-			configfile:              `{}`,
-			expectedExperimentalCLI: false,
-		},
-		{
-			doc: "experimental",
-			configfile: `{
-	"experimental": "enabled"
-}`,
-			expectedExperimentalCLI: true,
-		},
-	}
-
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			dir := fs.NewDir(t, testcase.doc, fs.WithFile("config.json", testcase.configfile))
-			defer dir.Remove()
-			apiclient := &fakeClient{
-				version: defaultVersion,
-			}
-
-			cli := &DockerCli{client: apiclient, err: os.Stderr}
-			cliconfig.SetDir(dir.Path())
-			err := cli.Initialize(flags.NewClientOptions())
-			assert.NilError(t, err)
-			assert.Check(t, is.Equal(testcase.expectedExperimentalCLI, cli.ClientInfo().HasExperimental))
-		})
-	}
-}
-
-func TestOrchestratorSwitch(t *testing.T) {
-	defaultVersion := "v0.00"
-
-	var testcases = []struct {
-		doc                  string
-		configfile           string
-		envOrchestrator      string
-		flagOrchestrator     string
-		expectedOrchestrator string
-		expectedKubernetes   bool
-	}{
-		{
-			doc: "default",
-			configfile: `{
-				"experimental": "enabled"
-			}`,
-			expectedOrchestrator: "swarm",
-			expectedKubernetes:   false,
-		},
-		{
-			doc: "kubernetesIsExperimental",
-			configfile: `{
-				"experimental": "disabled",
-				"orchestrator": "kubernetes"
-			}`,
-			envOrchestrator:      "kubernetes",
-			flagOrchestrator:     "kubernetes",
-			expectedOrchestrator: "swarm",
-			expectedKubernetes:   false,
-		},
-		{
-			doc: "kubernetesConfigFile",
-			configfile: `{
-				"experimental": "enabled",
-				"orchestrator": "kubernetes"
-			}`,
-			expectedOrchestrator: "kubernetes",
-			expectedKubernetes:   true,
-		},
-		{
-			doc: "kubernetesEnv",
-			configfile: `{
-				"experimental": "enabled"
-			}`,
-			envOrchestrator:      "kubernetes",
-			expectedOrchestrator: "kubernetes",
-			expectedKubernetes:   true,
-		},
-		{
-			doc: "kubernetesFlag",
-			configfile: `{
-				"experimental": "enabled"
-			}`,
-			flagOrchestrator:     "kubernetes",
-			expectedOrchestrator: "kubernetes",
-			expectedKubernetes:   true,
-		},
-		{
-			doc: "envOverridesConfigFile",
-			configfile: `{
-				"experimental": "enabled",
-				"orchestrator": "kubernetes"
-			}`,
-			envOrchestrator:      "swarm",
-			expectedOrchestrator: "swarm",
-			expectedKubernetes:   false,
-		},
-		{
-			doc: "flagOverridesEnv",
-			configfile: `{
-				"experimental": "enabled"
-			}`,
-			envOrchestrator:      "kubernetes",
-			flagOrchestrator:     "swarm",
-			expectedOrchestrator: "swarm",
-			expectedKubernetes:   false,
-		},
-	}
-
-	for _, testcase := range testcases {
-		t.Run(testcase.doc, func(t *testing.T) {
-			dir := fs.NewDir(t, testcase.doc, fs.WithFile("config.json", testcase.configfile))
-			defer dir.Remove()
-			apiclient := &fakeClient{
-				version: defaultVersion,
-			}
-			if testcase.envOrchestrator != "" {
-				defer patchEnvVariable(t, "DOCKER_ORCHESTRATOR", testcase.envOrchestrator)()
-			}
-
-			cli := &DockerCli{client: apiclient, err: os.Stderr}
-			cliconfig.SetDir(dir.Path())
-			options := flags.NewClientOptions()
-			if testcase.flagOrchestrator != "" {
-				options.Common.Orchestrator = testcase.flagOrchestrator
-			}
-			err := cli.Initialize(options)
-			assert.NilError(t, err)
-			assert.Check(t, is.Equal(testcase.expectedKubernetes, cli.ClientInfo().HasKubernetes()))
-			assert.Check(t, is.Equal(testcase.expectedOrchestrator, string(cli.ClientInfo().Orchestrator)))
+			assert.Equal(t, defaultVersion, cli.defaultVersion)
+			assert.Equal(t, testcase.expectedServer, cli.server)
+			assert.Equal(t, testcase.negotiated, apiclient.negotiated)
 		})
 	}
 }
@@ -334,11 +188,11 @@ func TestGetClientWithPassword(t *testing.T) {
 
 			_, err := getClientWithPassword(passRetriever, newClient)
 			if testcase.expectedErr != "" {
-				assert.ErrorContains(t, err, testcase.expectedErr)
+				testutil.ErrorContains(t, err, testcase.expectedErr)
 				return
 			}
 
-			assert.NilError(t, err)
+			assert.NoError(t, err)
 		})
 	}
 }

components/cli/cli/command/commands/commands.go

@@ -8,7 +8,6 @@ import (
 	"github.com/docker/cli/cli/command/config"
 	"github.com/docker/cli/cli/command/container"
 	"github.com/docker/cli/cli/command/image"
-	"github.com/docker/cli/cli/command/manifest"
 	"github.com/docker/cli/cli/command/network"
 	"github.com/docker/cli/cli/command/node"
 	"github.com/docker/cli/cli/command/plugin"
@@ -40,15 +39,12 @@ func AddCommands(cmd *cobra.Command, dockerCli *command.DockerCli) {
 		image.NewImageCommand(dockerCli),
 		image.NewBuildCommand(dockerCli),
 
-		// manifest
-		manifest.NewManifestCommand(dockerCli),
+		// node
+		node.NewNodeCommand(dockerCli),
 
 		// network
 		network.NewNetworkCommand(dockerCli),
 
-		// node
-		node.NewNodeCommand(dockerCli),
-
 		// plugin
 		plugin.NewPluginCommand(dockerCli),
 

components/cli/cli/command/config/cmd.go

@@ -10,14 +10,11 @@ import (
 // NewConfigCommand returns a cobra command for `config` subcommands
 func NewConfigCommand(dockerCli command.Cli) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "config",
-		Short: "Manage Docker configs",
-		Args:  cli.NoArgs,
-		RunE:  command.ShowHelp(dockerCli.Err()),
-		Annotations: map[string]string{
-			"version": "1.30",
-			"swarm":   "",
-		},
+		Use:         "config",
+		Short:       "Manage Docker configs",
+		Args:        cli.NoArgs,
+		RunE:        command.ShowHelp(dockerCli.Err()),
+		Annotations: map[string]string{"version": "1.30"},
 	}
 	cmd.AddCommand(
 		newConfigListCommand(dockerCli),

components/cli/cli/command/config/create.go

@@ -16,10 +16,9 @@ import (
 )
 
 type createOptions struct {
-	name           string
-	templateDriver string
-	file           string
-	labels         opts.ListOpts
+	name   string
+	file   string
+	labels opts.ListOpts
 }
 
 func newConfigCreateCommand(dockerCli command.Cli) *cobra.Command {
@@ -29,7 +28,7 @@ func newConfigCreateCommand(dockerCli command.Cli) *cobra.Command {
 
 	cmd := &cobra.Command{
 		Use:   "create [OPTIONS] CONFIG file|-",
-		Short: "Create a config from a file or STDIN",
+		Short: "Create a configuration file from a file or STDIN as content",
 		Args:  cli.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			createOpts.name = args[0]
@@ -39,8 +38,6 @@ func newConfigCreateCommand(dockerCli command.Cli) *cobra.Command {
 	}
 	flags := cmd.Flags()
 	flags.VarP(&createOpts.labels, "label", "l", "Config labels")
-	flags.StringVar(&createOpts.templateDriver, "template-driver", "", "Template driver")
-	flags.SetAnnotation("driver", "version", []string{"1.37"})
 
 	return cmd
 }
@@ -71,11 +68,7 @@ func runConfigCreate(dockerCli command.Cli, options createOptions) error {
 		},
 		Data: configData,
 	}
-	if options.templateDriver != "" {
-		spec.Templating = &swarm.Driver{
-			Name: options.templateDriver,
-		}
-	}
+
 	r, err := client.ConfigCreate(ctx, spec)
 	if err != nil {
 		return err

components/cli/cli/command/config/create_test.go

@@ -8,12 +8,12 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 const configDataFile = "config-create-with-name.golden"
@@ -47,7 +47,7 @@ func TestConfigCreateErrors(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -70,9 +70,9 @@ func TestConfigCreateWithName(t *testing.T) {
 
 	cmd := newConfigCreateCommand(cli)
 	cmd.SetArgs([]string{name, filepath.Join("testdata", configDataFile)})
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	golden.Assert(t, string(actual), configDataFile)
-	assert.Check(t, is.Equal("ID-"+name, strings.TrimSpace(cli.OutBuffer().String())))
+	assert.Equal(t, "ID-"+name, strings.TrimSpace(cli.OutBuffer().String()))
 }
 
 func TestConfigCreateWithLabels(t *testing.T) {
@@ -82,21 +82,14 @@ func TestConfigCreateWithLabels(t *testing.T) {
 	}
 	name := "foo"
 
-	data, err := ioutil.ReadFile(filepath.Join("testdata", configDataFile))
-	assert.NilError(t, err)
-
-	expected := swarm.ConfigSpec{
-		Annotations: swarm.Annotations{
-			Name:   name,
-			Labels: expectedLabels,
-		},
-		Data: data,
-	}
-
 	cli := test.NewFakeCli(&fakeClient{
 		configCreateFunc: func(spec swarm.ConfigSpec) (types.ConfigCreateResponse, error) {
-			if !reflect.DeepEqual(spec, expected) {
-				return types.ConfigCreateResponse{}, errors.Errorf("expected %+v, got %+v", expected, spec)
+			if spec.Name != name {
+				return types.ConfigCreateResponse{}, errors.Errorf("expected name %q, got %q", name, spec.Name)
+			}
+
+			if !reflect.DeepEqual(spec.Labels, expectedLabels) {
+				return types.ConfigCreateResponse{}, errors.Errorf("expected labels %v, got %v", expectedLabels, spec.Labels)
 			}
 
 			return types.ConfigCreateResponse{
@@ -109,35 +102,6 @@ func TestConfigCreateWithLabels(t *testing.T) {
 	cmd.SetArgs([]string{name, filepath.Join("testdata", configDataFile)})
 	cmd.Flags().Set("label", "lbl1=Label-foo")
 	cmd.Flags().Set("label", "lbl2=Label-bar")
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("ID-"+name, strings.TrimSpace(cli.OutBuffer().String())))
-}
-
-func TestConfigCreateWithTemplatingDriver(t *testing.T) {
-	expectedDriver := &swarm.Driver{
-		Name: "template-driver",
-	}
-	name := "foo"
-
-	cli := test.NewFakeCli(&fakeClient{
-		configCreateFunc: func(spec swarm.ConfigSpec) (types.ConfigCreateResponse, error) {
-			if spec.Name != name {
-				return types.ConfigCreateResponse{}, errors.Errorf("expected name %q, got %q", name, spec.Name)
-			}
-
-			if spec.Templating.Name != expectedDriver.Name {
-				return types.ConfigCreateResponse{}, errors.Errorf("expected driver %v, got %v", expectedDriver, spec.Labels)
-			}
-
-			return types.ConfigCreateResponse{
-				ID: "ID-" + spec.Name,
-			}, nil
-		},
-	})
-
-	cmd := newConfigCreateCommand(cli)
-	cmd.SetArgs([]string{name, filepath.Join("testdata", configDataFile)})
-	cmd.Flags().Set("template-driver", expectedDriver.Name)
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.Equal("ID-"+name, strings.TrimSpace(cli.OutBuffer().String())))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "ID-"+name, strings.TrimSpace(cli.OutBuffer().String()))
 }

components/cli/cli/command/config/inspect.go

@@ -21,7 +21,7 @@ func newConfigInspectCommand(dockerCli command.Cli) *cobra.Command {
 	opts := inspectOptions{}
 	cmd := &cobra.Command{
 		Use:   "inspect [OPTIONS] CONFIG [CONFIG...]",
-		Short: "Display detailed information on one or more configs",
+		Short: "Display detailed information on one or more configuration files",
 		Args:  cli.RequiresMinArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			opts.names = args

components/cli/cli/command/config/inspect_test.go

@@ -11,8 +11,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/cli/internal/test/builders"
-	"github.com/gotestyourself/gotestyourself/assert"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestConfigInspectErrors(t *testing.T) {
@@ -61,7 +62,7 @@ func TestConfigInspectErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -95,7 +96,7 @@ func TestConfigInspectWithoutFormat(t *testing.T) {
 		cli := test.NewFakeCli(&fakeClient{configInspectFunc: tc.configInspectFunc})
 		cmd := newConfigInspectCommand(cli)
 		cmd.SetArgs(tc.args)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("config-inspect-without-format.%s.golden", tc.name))
 	}
 }
@@ -132,7 +133,7 @@ func TestConfigInspectWithFormat(t *testing.T) {
 		cmd := newConfigInspectCommand(cli)
 		cmd.SetArgs(tc.args)
 		cmd.Flags().Set("format", tc.format)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("config-inspect-with-format.%s.golden", tc.name))
 	}
 }
@@ -166,7 +167,7 @@ func TestConfigInspectPretty(t *testing.T) {
 
 		cmd.SetArgs([]string{"configID"})
 		cmd.Flags().Set("pretty", "true")
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("config-inspect-pretty.%s.golden", tc.name))
 	}
 }

components/cli/cli/command/config/ls_test.go

@@ -12,9 +12,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/cli/internal/test/builders"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestConfigListErrors(t *testing.T) {
@@ -42,7 +42,7 @@ func TestConfigListErrors(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -72,7 +72,7 @@ func TestConfigList(t *testing.T) {
 		},
 	})
 	cmd := newConfigListCommand(cli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	golden.Assert(t, cli.OutBuffer().String(), "config-list-sort.golden")
 }
 
@@ -89,7 +89,7 @@ func TestConfigListWithQuietOption(t *testing.T) {
 	})
 	cmd := newConfigListCommand(cli)
 	cmd.Flags().Set("quiet", "true")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	golden.Assert(t, cli.OutBuffer().String(), "config-list-with-quiet-option.golden")
 }
 
@@ -108,7 +108,7 @@ func TestConfigListWithConfigFormat(t *testing.T) {
 		ConfigFormat: "{{ .Name }} {{ .Labels }}",
 	})
 	cmd := newConfigListCommand(cli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	golden.Assert(t, cli.OutBuffer().String(), "config-list-with-config-format.golden")
 }
 
@@ -125,15 +125,15 @@ func TestConfigListWithFormat(t *testing.T) {
 	})
 	cmd := newConfigListCommand(cli)
 	cmd.Flags().Set("format", "{{ .Name }} {{ .Labels }}")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	golden.Assert(t, cli.OutBuffer().String(), "config-list-with-format.golden")
 }
 
 func TestConfigListWithFilter(t *testing.T) {
 	cli := test.NewFakeCli(&fakeClient{
 		configListFunc: func(options types.ConfigListOptions) ([]swarm.Config, error) {
-			assert.Check(t, is.Equal("foo", options.Filters.Get("name")[0]))
-			assert.Check(t, is.Equal("lbl1=Label-bar", options.Filters.Get("label")[0]))
+			assert.Equal(t, "foo", options.Filters.Get("name")[0])
+			assert.Equal(t, "lbl1=Label-bar", options.Filters.Get("label")[0])
 			return []swarm.Config{
 				*Config(ConfigID("ID-foo"),
 					ConfigName("foo"),
@@ -153,6 +153,6 @@ func TestConfigListWithFilter(t *testing.T) {
 	cmd := newConfigListCommand(cli)
 	cmd.Flags().Set("filter", "name=foo")
 	cmd.Flags().Set("filter", "label=lbl1=Label-bar")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	golden.Assert(t, cli.OutBuffer().String(), "config-list-with-filter.golden")
 }

components/cli/cli/command/config/remove.go

@@ -19,7 +19,7 @@ func newConfigRemoveCommand(dockerCli command.Cli) *cobra.Command {
 	return &cobra.Command{
 		Use:     "rm CONFIG [CONFIG...]",
 		Aliases: []string{"remove"},
-		Short:   "Remove one or more configs",
+		Short:   "Remove one or more configuration files",
 		Args:    cli.RequiresMinArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			opts := removeOptions{

components/cli/cli/command/config/remove_test.go

@@ -6,9 +6,9 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestConfigRemoveErrors(t *testing.T) {
@@ -37,7 +37,7 @@ func TestConfigRemoveErrors(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -52,9 +52,9 @@ func TestConfigRemoveWithName(t *testing.T) {
 	})
 	cmd := newConfigRemoveCommand(cli)
 	cmd.SetArgs(names)
-	assert.NilError(t, cmd.Execute())
-	assert.Check(t, is.DeepEqual(names, strings.Split(strings.TrimSpace(cli.OutBuffer().String()), "\n")))
-	assert.Check(t, is.DeepEqual(names, removedConfigs))
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, names, strings.Split(strings.TrimSpace(cli.OutBuffer().String()), "\n"))
+	assert.Equal(t, names, removedConfigs)
 }
 
 func TestConfigRemoveContinueAfterError(t *testing.T) {
@@ -74,6 +74,6 @@ func TestConfigRemoveContinueAfterError(t *testing.T) {
 	cmd := newConfigRemoveCommand(cli)
 	cmd.SetArgs(names)
 	cmd.SetOutput(ioutil.Discard)
-	assert.Error(t, cmd.Execute(), "error removing config: foo")
-	assert.Check(t, is.DeepEqual(names, removedConfigs))
+	assert.EqualError(t, cmd.Execute(), "error removing config: foo")
+	assert.Equal(t, names, removedConfigs)
 }

components/cli/cli/command/container/attach.go

@@ -1,14 +1,12 @@
 package container
 
 import (
-	"fmt"
 	"io"
 	"net/http/httputil"
 
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/client"
 	"github.com/docker/docker/pkg/signal"
 	"github.com/pkg/errors"
@@ -68,9 +66,6 @@ func runAttach(dockerCli command.Cli, opts *attachOptions) error {
 	ctx := context.Background()
 	client := dockerCli.Client()
 
-	// request channel to wait for client
-	resultC, errC := client.ContainerWait(ctx, opts.container, "")
-
 	c, err := inspectContainerAndCheckState(ctx, client, opts.container)
 	if err != nil {
 		return err
@@ -145,24 +140,7 @@ func runAttach(dockerCli command.Cli, opts *attachOptions) error {
 	if errAttach != nil {
 		return errAttach
 	}
-
-	return getExitStatus(errC, resultC)
-}
-
-func getExitStatus(errC <-chan error, resultC <-chan container.ContainerWaitOKBody) error {
-	select {
-	case result := <-resultC:
-		if result.Error != nil {
-			return fmt.Errorf(result.Error.Message)
-		}
-		if result.StatusCode != 0 {
-			return cli.StatusError{StatusCode: int(result.StatusCode)}
-		}
-	case err := <-errC:
-		return err
-	}
-
-	return nil
+	return getExitStatus(ctx, dockerCli.Client(), opts.container)
 }
 
 func resizeTTY(ctx context.Context, dockerCli command.Cli, containerID string) {
@@ -179,3 +157,19 @@ func resizeTTY(ctx context.Context, dockerCli command.Cli, containerID string) {
 		logrus.Debugf("Error monitoring TTY size: %s", err)
 	}
 }
+
+func getExitStatus(ctx context.Context, apiclient client.ContainerAPIClient, containerID string) error {
+	container, err := apiclient.ContainerInspect(ctx, containerID)
+	if err != nil {
+		// If we can't connect, then the daemon probably died.
+		if !client.IsErrConnectionFailed(err) {
+			return err
+		}
+		return cli.StatusError{StatusCode: -1}
+	}
+	status := container.State.ExitCode
+	if status != 0 {
+		return cli.StatusError{StatusCode: status}
+	}
+	return nil
+}

components/cli/cli/command/container/attach_test.go

@@ -1,16 +1,16 @@
 package container
 
 import (
-	"fmt"
 	"io/ioutil"
 	"testing"
 
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/gotestyourself/gotestyourself/assert"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/net/context"
 )
 
 func TestNewAttachCommandErrors(t *testing.T) {
@@ -73,57 +73,45 @@ func TestNewAttachCommandErrors(t *testing.T) {
 		cmd := NewAttachCommand(test.NewFakeCli(&fakeClient{inspectFunc: tc.containerInspectFunc}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
 func TestGetExitStatus(t *testing.T) {
-	var (
-		expectedErr = fmt.Errorf("unexpected error")
-		errC        = make(chan error, 1)
-		resultC     = make(chan container.ContainerWaitOKBody, 1)
-	)
+	containerID := "the exec id"
+	expecatedErr := errors.New("unexpected error")
 
 	testcases := []struct {
-		result        *container.ContainerWaitOKBody
-		err           error
+		inspectError  error
+		exitCode      int
 		expectedError error
 	}{
 		{
-			result: &container.ContainerWaitOKBody{
-				StatusCode: 0,
-			},
+			inspectError: nil,
+			exitCode:     0,
 		},
 		{
-			err:           expectedErr,
-			expectedError: expectedErr,
+			inspectError:  expecatedErr,
+			expectedError: expecatedErr,
 		},
 		{
-			result: &container.ContainerWaitOKBody{
-				Error: &container.ContainerWaitOKBodyError{expectedErr.Error()},
-			},
-			expectedError: expectedErr,
-		},
-		{
-			result: &container.ContainerWaitOKBody{
-				StatusCode: 15,
-			},
+			exitCode:      15,
 			expectedError: cli.StatusError{StatusCode: 15},
 		},
 	}
 
 	for _, testcase := range testcases {
-		if testcase.err != nil {
-			errC <- testcase.err
-		}
-		if testcase.result != nil {
-			resultC <- *testcase.result
-		}
-		err := getExitStatus(errC, resultC)
-		if testcase.expectedError == nil {
-			assert.NilError(t, err)
-		} else {
-			assert.Error(t, err, testcase.expectedError.Error())
+		client := &fakeClient{
+			inspectFunc: func(id string) (types.ContainerJSON, error) {
+				assert.Equal(t, containerID, id)
+				return types.ContainerJSON{
+					ContainerJSONBase: &types.ContainerJSONBase{
+						State: &types.ContainerState{ExitCode: testcase.exitCode},
+					},
+				}, testcase.inspectError
+			},
 		}
+		err := getExitStatus(context.Background(), client, containerID)
+		assert.Equal(t, testcase.expectedError, err)
 	}
 }

components/cli/cli/command/container/client_test.go

@@ -16,22 +16,11 @@ type fakeClient struct {
 	execInspectFunc       func(execID string) (types.ContainerExecInspect, error)
 	execCreateFunc        func(container string, config types.ExecConfig) (types.IDResponse, error)
 	createContainerFunc   func(config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, containerName string) (container.ContainerCreateCreatedBody, error)
-	containerStartFunc    func(container string, options types.ContainerStartOptions) error
 	imageCreateFunc       func(parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error)
 	infoFunc              func() (types.Info, error)
 	containerStatPathFunc func(container, path string) (types.ContainerPathStat, error)
 	containerCopyFromFunc func(container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error)
 	logFunc               func(string, types.ContainerLogsOptions) (io.ReadCloser, error)
-	waitFunc              func(string) (<-chan container.ContainerWaitOKBody, <-chan error)
-	containerListFunc     func(types.ContainerListOptions) ([]types.Container, error)
-	Version               string
-}
-
-func (f *fakeClient) ContainerList(_ context.Context, options types.ContainerListOptions) ([]types.Container, error) {
-	if f.containerListFunc != nil {
-		return f.containerListFunc(options)
-	}
-	return []types.Container{}, nil
 }
 
 func (f *fakeClient) ContainerInspect(_ context.Context, containerID string) (types.ContainerJSON, error) {
@@ -106,21 +95,3 @@ func (f *fakeClient) ContainerLogs(_ context.Context, container string, options
 	}
 	return nil, nil
 }
-
-func (f *fakeClient) ClientVersion() string {
-	return f.Version
-}
-
-func (f *fakeClient) ContainerWait(_ context.Context, container string, _ container.WaitCondition) (<-chan container.ContainerWaitOKBody, <-chan error) {
-	if f.waitFunc != nil {
-		return f.waitFunc(container)
-	}
-	return nil, nil
-}
-
-func (f *fakeClient) ContainerStart(_ context.Context, container string, options types.ContainerStartOptions) error {
-	if f.containerStartFunc != nil {
-		return f.containerStartFunc(container, options)
-	}
-	return nil
-}

components/cli/cli/command/container/cp_test.go

@@ -3,18 +3,18 @@ package container
 import (
 	"io"
 	"io/ioutil"
-	"os"
 	"runtime"
 	"strings"
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/fs"
 	"github.com/gotestyourself/gotestyourself/skip"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRunCopyWithInvalidArguments(t *testing.T) {
@@ -43,7 +43,7 @@ func TestRunCopyWithInvalidArguments(t *testing.T) {
 	for _, testcase := range testcases {
 		t.Run(testcase.doc, func(t *testing.T) {
 			err := runCopy(test.NewFakeCli(nil), testcase.options)
-			assert.Error(t, err, testcase.expectedErr)
+			assert.EqualError(t, err, testcase.expectedErr)
 		})
 	}
 }
@@ -53,16 +53,16 @@ func TestRunCopyFromContainerToStdout(t *testing.T) {
 
 	fakeClient := &fakeClient{
 		containerCopyFromFunc: func(container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
-			assert.Check(t, is.Equal("container", container))
+			assert.Equal(t, "container", container)
 			return ioutil.NopCloser(strings.NewReader(tarContent)), types.ContainerPathStat{}, nil
 		},
 	}
 	options := copyOptions{source: "container:/path", destination: "-"}
 	cli := test.NewFakeCli(fakeClient)
 	err := runCopy(cli, options)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(tarContent, cli.OutBuffer().String()))
-	assert.Check(t, is.Equal("", cli.ErrBuffer().String()))
+	require.NoError(t, err)
+	assert.Equal(t, tarContent, cli.OutBuffer().String())
+	assert.Equal(t, "", cli.ErrBuffer().String())
 }
 
 func TestRunCopyFromContainerToFilesystem(t *testing.T) {
@@ -72,7 +72,7 @@ func TestRunCopyFromContainerToFilesystem(t *testing.T) {
 
 	fakeClient := &fakeClient{
 		containerCopyFromFunc: func(container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
-			assert.Check(t, is.Equal("container", container))
+			assert.Equal(t, "container", container)
 			readCloser, err := archive.TarWithOptions(destDir.Path(), &archive.TarOptions{})
 			return readCloser, types.ContainerPathStat{}, err
 		},
@@ -80,13 +80,13 @@ func TestRunCopyFromContainerToFilesystem(t *testing.T) {
 	options := copyOptions{source: "container:/path", destination: destDir.Path()}
 	cli := test.NewFakeCli(fakeClient)
 	err := runCopy(cli, options)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal("", cli.OutBuffer().String()))
-	assert.Check(t, is.Equal("", cli.ErrBuffer().String()))
+	require.NoError(t, err)
+	assert.Equal(t, "", cli.OutBuffer().String())
+	assert.Equal(t, "", cli.ErrBuffer().String())
 
 	content, err := ioutil.ReadFile(destDir.Join("file1"))
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal("content\n", string(content)))
+	require.NoError(t, err)
+	assert.Equal(t, "content\n", string(content))
 }
 
 func TestRunCopyFromContainerToFilesystemMissingDestinationDirectory(t *testing.T) {
@@ -96,7 +96,7 @@ func TestRunCopyFromContainerToFilesystemMissingDestinationDirectory(t *testing.
 
 	fakeClient := &fakeClient{
 		containerCopyFromFunc: func(container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
-			assert.Check(t, is.Equal("container", container))
+			assert.Equal(t, "container", container)
 			readCloser, err := archive.TarWithOptions(destDir.Path(), &archive.TarOptions{})
 			return readCloser, types.ContainerPathStat{}, err
 		},
@@ -108,39 +108,7 @@ func TestRunCopyFromContainerToFilesystemMissingDestinationDirectory(t *testing.
 	}
 	cli := test.NewFakeCli(fakeClient)
 	err := runCopy(cli, options)
-	assert.ErrorContains(t, err, destDir.Join("missing"))
-}
-
-func TestRunCopyToContainerFromFileWithTrailingSlash(t *testing.T) {
-	srcFile := fs.NewFile(t, t.Name())
-	defer srcFile.Remove()
-
-	options := copyOptions{
-		source:      srcFile.Path() + string(os.PathSeparator),
-		destination: "container:/path",
-	}
-	cli := test.NewFakeCli(&fakeClient{})
-	err := runCopy(cli, options)
-
-	expectedError := "not a directory"
-	if runtime.GOOS == "windows" {
-		expectedError = "The filename, directory name, or volume label syntax is incorrect"
-	}
-	assert.ErrorContains(t, err, expectedError)
-}
-
-func TestRunCopyToContainerSourceDoesNotExist(t *testing.T) {
-	options := copyOptions{
-		source:      "/does/not/exist",
-		destination: "container:/path",
-	}
-	cli := test.NewFakeCli(&fakeClient{})
-	err := runCopy(cli, options)
-	expected := "no such file or directory"
-	if runtime.GOOS == "windows" {
-		expected = "cannot find the file specified"
-	}
-	assert.ErrorContains(t, err, expected)
+	testutil.ErrorContains(t, err, destDir.Join("missing"))
 }
 
 func TestSplitCpArg(t *testing.T) {
@@ -185,8 +153,8 @@ func TestSplitCpArg(t *testing.T) {
 			skip.IfCondition(t, testcase.os != "" && testcase.os != runtime.GOOS)
 
 			container, path := splitCpArg(testcase.path)
-			assert.Check(t, is.Equal(testcase.expectedContainer, container))
-			assert.Check(t, is.Equal(testcase.expectedPath, path))
+			assert.Equal(t, testcase.expectedContainer, container)
+			assert.Equal(t, testcase.expectedPath, path)
 		})
 	}
 }

components/cli/cli/command/container/create.go

@@ -21,9 +21,8 @@ import (
 )
 
 type createOptions struct {
-	name      string
-	platform  string
-	untrusted bool
+	name     string
+	platform string
 }
 
 // NewCreateCommand creates a new cobra.Command for `docker create`
@@ -54,7 +53,7 @@ func NewCreateCommand(dockerCli command.Cli) *cobra.Command {
 	flags.Bool("help", false, "Print usage")
 
 	command.AddPlatformFlag(flags, &opts.platform)
-	command.AddTrustVerificationFlags(flags, &opts.untrusted, dockerCli.ContentTrustEnabled())
+	command.AddTrustVerificationFlags(flags)
 	copts = addFlags(flags)
 	return cmd
 }
@@ -65,7 +64,7 @@ func runCreate(dockerCli command.Cli, flags *pflag.FlagSet, opts *createOptions,
 		reportError(dockerCli.Err(), "create", err.Error(), true)
 		return cli.StatusError{StatusCode: 125}
 	}
-	response, err := createContainer(context.Background(), dockerCli, containerConfig, opts)
+	response, err := createContainer(context.Background(), dockerCli, containerConfig, opts.name, opts.platform)
 	if err != nil {
 		return err
 	}
@@ -159,7 +158,7 @@ func newCIDFile(path string) (*cidFile, error) {
 	return &cidFile{path: path, file: f}, nil
 }
 
-func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig *containerConfig, opts *createOptions) (*container.ContainerCreateCreatedBody, error) {
+func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig *containerConfig, name string, platform string) (*container.ContainerCreateCreatedBody, error) {
 	config := containerConfig.Config
 	hostConfig := containerConfig.HostConfig
 	networkingConfig := containerConfig.NetworkingConfig
@@ -183,7 +182,7 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig
 	if named, ok := ref.(reference.Named); ok {
 		namedRef = reference.TagNameOnly(named)
 
-		if taggedRef, ok := namedRef.(reference.NamedTagged); ok && !opts.untrusted {
+		if taggedRef, ok := namedRef.(reference.NamedTagged); ok && command.IsTrusted() {
 			var err error
 			trustedRef, err = image.TrustedReference(ctx, dockerCli, taggedRef, nil)
 			if err != nil {
@@ -194,7 +193,7 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig
 	}
 
 	//create the container
-	response, err := dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, opts.name)
+	response, err := dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, name)
 
 	//if image not found try to pull it
 	if err != nil {
@@ -202,7 +201,7 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig
 			fmt.Fprintf(stderr, "Unable to find image '%s' locally\n", reference.FamiliarString(namedRef))
 
 			// we don't want to write to stdout anything apart from container.ID
-			if err := pullImage(ctx, dockerCli, config.Image, opts.platform, stderr); err != nil {
+			if err := pullImage(ctx, dockerCli, config.Image, platform, stderr); err != nil {
 				return nil, err
 			}
 			if taggedRef, ok := namedRef.(reference.NamedTagged); ok && trustedRef != nil {
@@ -212,7 +211,7 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerConfig
 			}
 			// Retry
 			var retryErr error
-			response, retryErr = dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, opts.name)
+			response, retryErr = dockerCli.Client().ContainerCreate(ctx, config, hostConfig, networkingConfig, name)
 			if retryErr != nil {
 				return nil, retryErr
 			}

components/cli/cli/command/container/create_test.go

@@ -2,7 +2,6 @@ package container
 
 import (
 	"context"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -11,24 +10,23 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
-	"github.com/docker/cli/internal/test/notary"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/network"
-	"github.com/google/go-cmp/cmp"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/fs"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCIDFileNoOPWithNoFilename(t *testing.T) {
 	file, err := newCIDFile("")
-	assert.NilError(t, err)
-	assert.DeepEqual(t, &cidFile{}, file, cmp.AllowUnexported(cidFile{}))
+	require.NoError(t, err)
+	assert.Equal(t, &cidFile{}, file)
 
-	assert.NilError(t, file.Write("id"))
-	assert.NilError(t, file.Close())
+	assert.NoError(t, file.Write("id"))
+	assert.NoError(t, file.Close())
 }
 
 func TestNewCIDFileWhenFileAlreadyExists(t *testing.T) {
@@ -36,7 +34,7 @@ func TestNewCIDFileWhenFileAlreadyExists(t *testing.T) {
 	defer tempfile.Remove()
 
 	_, err := newCIDFile(tempfile.Path())
-	assert.ErrorContains(t, err, "Container ID file found")
+	testutil.ErrorContains(t, err, "Container ID file found")
 }
 
 func TestCIDFileCloseWithNoWrite(t *testing.T) {
@@ -45,12 +43,12 @@ func TestCIDFileCloseWithNoWrite(t *testing.T) {
 
 	path := tempdir.Join("cidfile")
 	file, err := newCIDFile(path)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(file.path, path))
+	require.NoError(t, err)
+	assert.Equal(t, file.path, path)
 
-	assert.NilError(t, file.Close())
+	assert.NoError(t, file.Close())
 	_, err = os.Stat(path)
-	assert.Check(t, os.IsNotExist(err))
+	assert.True(t, os.IsNotExist(err))
 }
 
 func TestCIDFileCloseWithWrite(t *testing.T) {
@@ -59,18 +57,18 @@ func TestCIDFileCloseWithWrite(t *testing.T) {
 
 	path := tempdir.Join("cidfile")
 	file, err := newCIDFile(path)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	content := "id"
-	assert.NilError(t, file.Write(content))
+	assert.NoError(t, file.Write(content))
 
 	actual, err := ioutil.ReadFile(path)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(content, string(actual)))
+	require.NoError(t, err)
+	assert.Equal(t, content, string(actual))
 
-	assert.NilError(t, file.Close())
+	assert.NoError(t, file.Close())
 	_, err = os.Stat(path)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 }
 
 func TestCreateContainerPullsImageIfMissing(t *testing.T) {
@@ -109,61 +107,12 @@ func TestCreateContainerPullsImageIfMissing(t *testing.T) {
 		},
 		HostConfig: &container.HostConfig{},
 	}
-	body, err := createContainer(context.Background(), cli, config, &createOptions{
-		name:      "name",
-		platform:  runtime.GOOS,
-		untrusted: true,
-	})
-	assert.NilError(t, err)
+	body, err := createContainer(context.Background(), cli, config, "name", runtime.GOOS)
+	require.NoError(t, err)
 	expected := container.ContainerCreateCreatedBody{ID: containerID}
-	assert.Check(t, is.DeepEqual(expected, *body))
+	assert.Equal(t, expected, *body)
 	stderr := cli.ErrBuffer().String()
-	assert.Check(t, is.Contains(stderr, "Unable to find image 'does-not-exist-locally:latest' locally"))
-}
-
-func TestNewCreateCommandWithContentTrustErrors(t *testing.T) {
-	testCases := []struct {
-		name          string
-		args          []string
-		expectedError string
-		notaryFunc    test.NotaryClientFuncType
-	}{
-		{
-			name:          "offline-notary-server",
-			notaryFunc:    notary.GetOfflineNotaryRepository,
-			expectedError: "client is offline",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "uninitialized-notary-server",
-			notaryFunc:    notary.GetUninitializedNotaryRepository,
-			expectedError: "remote trust data does not exist",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "empty-notary-server",
-			notaryFunc:    notary.GetEmptyTargetsNotaryRepository,
-			expectedError: "No valid trust data for tag",
-			args:          []string{"image:tag"},
-		},
-	}
-	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
-			createContainerFunc: func(config *container.Config,
-				hostConfig *container.HostConfig,
-				networkingConfig *network.NetworkingConfig,
-				containerName string,
-			) (container.ContainerCreateCreatedBody, error) {
-				return container.ContainerCreateCreatedBody{}, fmt.Errorf("shouldn't try to pull image")
-			},
-		}, test.EnableContentTrust)
-		cli.SetNotaryClient(tc.notaryFunc)
-		cmd := NewCreateCommand(cli)
-		cmd.SetOutput(ioutil.Discard)
-		cmd.SetArgs(tc.args)
-		err := cmd.Execute()
-		assert.ErrorContains(t, err, tc.expectedError)
-	}
+	assert.Contains(t, stderr, "Unable to find image 'does-not-exist-locally:latest' locally")
 }
 
 type fakeNotFound struct{}

components/cli/cli/command/container/exec_test.go

@@ -7,11 +7,11 @@ import (
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/config/configfile"
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/cli/opts"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
 )
 
@@ -106,7 +106,7 @@ func TestParseExec(t *testing.T) {
 
 	for _, testcase := range testcases {
 		execConfig := parseExec(testcase.options, &testcase.configFile)
-		assert.Check(t, is.DeepEqual(testcase.expected, *execConfig))
+		assert.Equal(t, testcase.expected, *execConfig)
 	}
 }
 
@@ -150,14 +150,14 @@ func TestRunExec(t *testing.T) {
 
 			err := runExec(cli, testcase.options)
 			if testcase.expectedError != "" {
-				assert.ErrorContains(t, err, testcase.expectedError)
+				testutil.ErrorContains(t, err, testcase.expectedError)
 			} else {
-				if !assert.Check(t, err) {
+				if !assert.NoError(t, err) {
 					return
 				}
 			}
-			assert.Check(t, is.Equal(testcase.expectedOut, cli.OutBuffer().String()))
-			assert.Check(t, is.Equal(testcase.expectedErr, cli.ErrBuffer().String()))
+			assert.Equal(t, testcase.expectedOut, cli.OutBuffer().String())
+			assert.Equal(t, testcase.expectedErr, cli.ErrBuffer().String())
 		})
 	}
 }
@@ -192,12 +192,12 @@ func TestGetExecExitStatus(t *testing.T) {
 	for _, testcase := range testcases {
 		client := &fakeClient{
 			execInspectFunc: func(id string) (types.ContainerExecInspect, error) {
-				assert.Check(t, is.Equal(execID, id))
+				assert.Equal(t, execID, id)
 				return types.ContainerExecInspect{ExitCode: testcase.exitCode}, testcase.inspectError
 			},
 		}
 		err := getExecExitStatus(context.Background(), client, execID)
-		assert.Check(t, is.Equal(testcase.expectedError, err))
+		assert.Equal(t, testcase.expectedError, err)
 	}
 }
 
@@ -222,6 +222,6 @@ func TestNewExecCommandErrors(t *testing.T) {
 		cmd := NewExecCommand(cli)
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }

components/cli/cli/command/container/list_test.go

@@ -1,164 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"io/ioutil"
-	"testing"
-
-	"github.com/docker/cli/cli/config/configfile"
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/docker/api/types"
-	// Import builders to get the builder function as package function
-	. "github.com/docker/cli/internal/test/builders"
-	"github.com/gotestyourself/gotestyourself/assert"
-	"github.com/gotestyourself/gotestyourself/golden"
-)
-
-func TestContainerListErrors(t *testing.T) {
-	testCases := []struct {
-		args              []string
-		flags             map[string]string
-		containerListFunc func(types.ContainerListOptions) ([]types.Container, error)
-		expectedError     string
-	}{
-		{
-			flags: map[string]string{
-				"format": "{{invalid}}",
-			},
-			expectedError: `function "invalid" not defined`,
-		},
-		{
-			flags: map[string]string{
-				"format": "{{join}}",
-			},
-			expectedError: `wrong number of args for join`,
-		},
-		{
-			containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-				return nil, fmt.Errorf("error listing containers")
-			},
-			expectedError: "error listing containers",
-		},
-	}
-	for _, tc := range testCases {
-		cmd := newListCommand(
-			test.NewFakeCli(&fakeClient{
-				containerListFunc: tc.containerListFunc,
-			}),
-		)
-		cmd.SetArgs(tc.args)
-		for key, value := range tc.flags {
-			cmd.Flags().Set(key, value)
-		}
-		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
-	}
-}
-
-func TestContainerListWithoutFormat(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1"),
-				*Container("c2", WithName("foo")),
-				*Container("c3", WithPort(80, 80, TCP), WithPort(81, 81, TCP), WithPort(82, 82, TCP)),
-				*Container("c4", WithPort(81, 81, UDP)),
-				*Container("c5", WithPort(82, 82, IP("8.8.8.8"), TCP)),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-without-format.golden")
-}
-
-func TestContainerListNoTrunc(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1"),
-				*Container("c2", WithName("foo/bar")),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("no-trunc", "true")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-without-format-no-trunc.golden")
-}
-
-// Test for GitHub issue docker/docker#21772
-func TestContainerListNamesMultipleTime(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1"),
-				*Container("c2", WithName("foo/bar")),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("format", "{{.Names}} {{.Names}}")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-format-name-name.golden")
-}
-
-// Test for GitHub issue docker/docker#30291
-func TestContainerListFormatTemplateWithArg(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1", WithLabel("some.label", "value")),
-				*Container("c2", WithName("foo/bar"), WithLabel("foo", "bar")),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("format", `{{.Names}} {{.Label "some.label"}}`)
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-format-with-arg.golden")
-}
-
-func TestContainerListFormatSizeSetsOption(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(options types.ContainerListOptions) ([]types.Container, error) {
-			assert.Check(t, options.Size)
-			return []types.Container{}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("format", `{{.Size}}`)
-	assert.NilError(t, cmd.Execute())
-}
-
-func TestContainerListWithConfigFormat(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1", WithLabel("some.label", "value")),
-				*Container("c2", WithName("foo/bar"), WithLabel("foo", "bar")),
-			}, nil
-		},
-	})
-	cli.SetConfigFile(&configfile.ConfigFile{
-		PsFormat: "{{ .Names }} {{ .Image }} {{ .Labels }}",
-	})
-	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-with-config-format.golden")
-}
-
-func TestContainerListWithFormat(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		containerListFunc: func(_ types.ContainerListOptions) ([]types.Container, error) {
-			return []types.Container{
-				*Container("c1", WithLabel("some.label", "value")),
-				*Container("c2", WithName("foo/bar"), WithLabel("foo", "bar")),
-			}, nil
-		},
-	})
-	cmd := newListCommand(cli)
-	cmd.Flags().Set("format", "{{ .Names }} {{ .Image }} {{ .Labels }}")
-	assert.NilError(t, cmd.Execute())
-	golden.Assert(t, cli.OutBuffer().String(), "container-list-with-format.golden")
-}

components/cli/cli/command/container/logs_test.go

@@ -7,10 +7,10 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 var logFn = func(expectedOut string) func(string, types.ContainerLogsOptions) (io.ReadCloser, error) {
@@ -49,14 +49,14 @@ func TestRunLogs(t *testing.T) {
 
 			err := runLogs(cli, testcase.options)
 			if testcase.expectedError != "" {
-				assert.ErrorContains(t, err, testcase.expectedError)
+				testutil.ErrorContains(t, err, testcase.expectedError)
 			} else {
-				if !assert.Check(t, err) {
+				if !assert.NoError(t, err) {
 					return
 				}
 			}
-			assert.Check(t, is.Equal(testcase.expectedOut, cli.OutBuffer().String()))
-			assert.Check(t, is.Equal(testcase.expectedErr, cli.ErrBuffer().String()))
+			assert.Equal(t, testcase.expectedOut, cli.OutBuffer().String())
+			assert.Equal(t, testcase.expectedErr, cli.ErrBuffer().String())
 		})
 	}
 }

components/cli/cli/command/container/opts.go

@@ -145,7 +145,7 @@ func addFlags(flags *pflag.FlagSet) *containerOptions {
 		expose:            opts.NewListOpts(nil),
 		extraHosts:        opts.NewListOpts(opts.ValidateExtraHost),
 		groupAdd:          opts.NewListOpts(nil),
-		labels:            opts.NewListOpts(nil),
+		labels:            opts.NewListOpts(opts.ValidateEnv),
 		labelsFile:        opts.NewListOpts(nil),
 		linkLocalIPs:      opts.NewListOpts(nil),
 		links:             opts.NewListOpts(opts.ValidateLink),
@@ -410,7 +410,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions) (*containerConfig, err
 	}
 
 	// collect all the environment variables for the container
-	envVariables, err := opts.ReadKVEnvStrings(copts.envFile.GetAll(), copts.env.GetAll())
+	envVariables, err := opts.ReadKVStrings(copts.envFile.GetAll(), copts.env.GetAll())
 	if err != nil {
 		return nil, err
 	}

components/cli/cli/command/container/opts_test.go

@@ -9,13 +9,14 @@ import (
 	"testing"
 	"time"
 
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types/container"
 	networktypes "github.com/docker/docker/api/types/network"
 	"github.com/docker/go-connections/nat"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestValidateAttach(t *testing.T) {
@@ -66,12 +67,12 @@ func setupRunFlags() (*pflag.FlagSet, *containerOptions) {
 
 func parseMustError(t *testing.T, args string) {
 	_, _, _, err := parseRun(strings.Split(args+" ubuntu bash", " "))
-	assert.ErrorContains(t, err, "", args)
+	assert.Error(t, err, args)
 }
 
 func mustParse(t *testing.T, args string) (*container.Config, *container.HostConfig) {
 	config, hostConfig, _, err := parseRun(append(strings.Split(args, " "), "ubuntu", "bash"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 	return config, hostConfig
 }
 
@@ -235,23 +236,23 @@ func TestRunFlagsParseWithMemory(t *testing.T) {
 	flags, _ := setupRunFlags()
 	args := []string{"--memory=invalid", "img", "cmd"}
 	err := flags.Parse(args)
-	assert.ErrorContains(t, err, `invalid argument "invalid" for "-m, --memory" flag`)
+	testutil.ErrorContains(t, err, `invalid argument "invalid" for "-m, --memory" flag`)
 
 	_, hostconfig := mustParse(t, "--memory=1G")
-	assert.Check(t, is.Equal(int64(1073741824), hostconfig.Memory))
+	assert.Equal(t, int64(1073741824), hostconfig.Memory)
 }
 
 func TestParseWithMemorySwap(t *testing.T) {
 	flags, _ := setupRunFlags()
 	args := []string{"--memory-swap=invalid", "img", "cmd"}
 	err := flags.Parse(args)
-	assert.ErrorContains(t, err, `invalid argument "invalid" for "--memory-swap" flag`)
+	testutil.ErrorContains(t, err, `invalid argument "invalid" for "--memory-swap" flag`)
 
 	_, hostconfig := mustParse(t, "--memory-swap=1G")
-	assert.Check(t, is.Equal(int64(1073741824), hostconfig.MemorySwap))
+	assert.Equal(t, int64(1073741824), hostconfig.MemorySwap)
 
 	_, hostconfig = mustParse(t, "--memory-swap=-1")
-	assert.Check(t, is.Equal(int64(-1), hostconfig.MemorySwap))
+	assert.Equal(t, int64(-1), hostconfig.MemorySwap)
 }
 
 func TestParseHostname(t *testing.T) {
@@ -372,24 +373,24 @@ func TestParseModes(t *testing.T) {
 	// pid ko
 	flags, copts := setupRunFlags()
 	args := []string{"--pid=container:", "img", "cmd"}
-	assert.NilError(t, flags.Parse(args))
+	require.NoError(t, flags.Parse(args))
 	_, err := parse(flags, copts)
-	assert.ErrorContains(t, err, "--pid: invalid PID mode")
+	testutil.ErrorContains(t, err, "--pid: invalid PID mode")
 
 	// pid ok
 	_, hostconfig, _, err := parseRun([]string{"--pid=host", "img", "cmd"})
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	if !hostconfig.PidMode.Valid() {
 		t.Fatalf("Expected a valid PidMode, got %v", hostconfig.PidMode)
 	}
 
 	// uts ko
 	_, _, _, err = parseRun([]string{"--uts=container:", "img", "cmd"})
-	assert.ErrorContains(t, err, "--uts: invalid UTS mode")
+	testutil.ErrorContains(t, err, "--uts: invalid UTS mode")
 
 	// uts ok
 	_, hostconfig, _, err = parseRun([]string{"--uts=host", "img", "cmd"})
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	if !hostconfig.UTSMode.Valid() {
 		t.Fatalf("Expected a valid UTSMode, got %v", hostconfig.UTSMode)
 	}
@@ -401,11 +402,11 @@ func TestRunFlagsParseShmSize(t *testing.T) {
 	args := []string{"--shm-size=a128m", "img", "cmd"}
 	expectedErr := `invalid argument "a128m" for "--shm-size" flag: invalid size: 'a128m'`
 	err := flags.Parse(args)
-	assert.ErrorContains(t, err, expectedErr)
+	testutil.ErrorContains(t, err, expectedErr)
 
 	// shm-size ok
 	_, hostconfig, _, err := parseRun([]string{"--shm-size=128m", "img", "cmd"})
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	if hostconfig.ShmSize != 134217728 {
 		t.Fatalf("Expected a valid ShmSize, got %d", hostconfig.ShmSize)
 	}

components/cli/cli/command/container/ps_test.go

@@ -4,14 +4,13 @@ import (
 	"testing"
 
 	"github.com/docker/cli/opts"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestBuildContainerListOptions(t *testing.T) {
 	filters := opts.NewFilterOpt()
-	assert.NilError(t, filters.Set("foo=bar"))
-	assert.NilError(t, filters.Set("baz=foo"))
+	assert.NoError(t, filters.Set("foo=bar"))
+	assert.NoError(t, filters.Set("baz=foo"))
 
 	contexts := []struct {
 		psOpts          *psOptions
@@ -102,12 +101,12 @@ func TestBuildContainerListOptions(t *testing.T) {
 
 	for _, c := range contexts {
 		options, err := buildContainerListOptions(c.psOpts)
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 
-		assert.Check(t, is.Equal(c.expectedAll, options.All))
-		assert.Check(t, is.Equal(c.expectedSize, options.Size))
-		assert.Check(t, is.Equal(c.expectedLimit, options.Limit))
-		assert.Check(t, is.Equal(len(c.expectedFilters), options.Filters.Len()))
+		assert.Equal(t, c.expectedAll, options.All)
+		assert.Equal(t, c.expectedSize, options.Size)
+		assert.Equal(t, c.expectedLimit, options.Limit)
+		assert.Equal(t, len(c.expectedFilters), options.Filters.Len())
 
 		for k, v := range c.expectedFilters {
 			f := options.Filters

components/cli/cli/command/container/run.go

@@ -25,10 +25,11 @@ import (
 )
 
 type runOptions struct {
-	createOptions
 	detach     bool
 	sigProxy   bool
+	name       string
 	detachKeys string
+	platform   string
 }
 
 // NewRunCommand create a new `docker run` command
@@ -63,7 +64,7 @@ func NewRunCommand(dockerCli command.Cli) *cobra.Command {
 	flags.Bool("help", false, "Print usage")
 
 	command.AddPlatformFlag(flags, &opts.platform)
-	command.AddTrustVerificationFlags(flags, &opts.untrusted, dockerCli.ContentTrustEnabled())
+	command.AddTrustVerificationFlags(flags)
 	copts = addFlags(flags)
 	return cmd
 }
@@ -161,7 +162,7 @@ func runContainer(dockerCli command.Cli, opts *runOptions, copts *containerOptio
 
 	ctx, cancelFun := context.WithCancel(context.Background())
 
-	createResponse, err := createContainer(ctx, dockerCli, containerConfig, &opts.createOptions)
+	createResponse, err := createContainer(ctx, dockerCli, containerConfig, opts.name, opts.platform)
 	if err != nil {
 		reportError(stderr, cmdPath, err.Error(), true)
 		return runStartContainerErr(err)

components/cli/cli/command/container/run_test.go

@@ -1,73 +0,0 @@
-package container
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/cli/internal/test/notary"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/network"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-)
-
-func TestRunLabel(t *testing.T) {
-	cli := test.NewFakeCli(&fakeClient{
-		createContainerFunc: func(_ *container.Config, _ *container.HostConfig, _ *network.NetworkingConfig, _ string) (container.ContainerCreateCreatedBody, error) {
-			return container.ContainerCreateCreatedBody{
-				ID: "id",
-			}, nil
-		},
-		Version: "1.36",
-	})
-	cmd := NewRunCommand(cli)
-	cmd.Flags().Set("detach", "true")
-	cmd.SetArgs([]string{"--label", "foo", "busybox"})
-	assert.NilError(t, cmd.Execute())
-}
-
-func TestRunCommandWithContentTrustErrors(t *testing.T) {
-	testCases := []struct {
-		name          string
-		args          []string
-		expectedError string
-		notaryFunc    test.NotaryClientFuncType
-	}{
-		{
-			name:          "offline-notary-server",
-			notaryFunc:    notary.GetOfflineNotaryRepository,
-			expectedError: "client is offline",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "uninitialized-notary-server",
-			notaryFunc:    notary.GetUninitializedNotaryRepository,
-			expectedError: "remote trust data does not exist",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "empty-notary-server",
-			notaryFunc:    notary.GetEmptyTargetsNotaryRepository,
-			expectedError: "No valid trust data for tag",
-			args:          []string{"image:tag"},
-		},
-	}
-	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
-			createContainerFunc: func(config *container.Config,
-				hostConfig *container.HostConfig,
-				networkingConfig *network.NetworkingConfig,
-				containerName string,
-			) (container.ContainerCreateCreatedBody, error) {
-				return container.ContainerCreateCreatedBody{}, fmt.Errorf("shouldn't try to pull image")
-			},
-		}, test.EnableContentTrust)
-		cli.SetNotaryClient(tc.notaryFunc)
-		cmd := NewRunCommand(cli)
-		cmd.SetArgs(tc.args)
-		err := cmd.Execute()
-		assert.Assert(t, err != nil)
-		assert.Assert(t, is.Contains(cli.ErrBuffer().String(), tc.expectedError))
-	}
-}

components/cli/cli/command/container/stats_helpers_test.go

@@ -1,11 +1,10 @@
 package container
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCalculateMemUsageUnixNoCache(t *testing.T) {
@@ -16,7 +15,7 @@ func TestCalculateMemUsageUnixNoCache(t *testing.T) {
 	result := calculateMemUsageUnixNoCache(stats)
 
 	// Then
-	assert.Assert(t, inDelta(100.0, result, 1e-6))
+	assert.InDelta(t, 100.0, result, 1e-6)
 }
 
 func TestCalculateMemPercentUnixNoCache(t *testing.T) {
@@ -28,20 +27,10 @@ func TestCalculateMemPercentUnixNoCache(t *testing.T) {
 	// When and Then
 	t.Run("Limit is set", func(t *testing.T) {
 		result := calculateMemPercentUnixNoCache(someLimit, used)
-		assert.Assert(t, inDelta(70.0, result, 1e-6))
+		assert.InDelta(t, 70.0, result, 1e-6)
 	})
 	t.Run("No limit, no cgroup data", func(t *testing.T) {
 		result := calculateMemPercentUnixNoCache(noLimit, used)
-		assert.Assert(t, inDelta(0.0, result, 1e-6))
+		assert.InDelta(t, 0.0, result, 1e-6)
 	})
 }
-
-func inDelta(x, y, delta float64) func() (bool, string) {
-	return func() (bool, string) {
-		diff := x - y
-		if diff < -delta || diff > delta {
-			return false, fmt.Sprintf("%f != %f within %f", x, y, delta)
-		}
-		return true, ""
-	}
-}

components/cli/cli/command/container/testdata/container-list-format-name-name.golden

@@ -1,2 +0,0 @@
-c1 c1
-c2 c2

components/cli/cli/command/container/testdata/container-list-format-with-arg.golden

@@ -1,2 +0,0 @@
-c1 value
-c2 

components/cli/cli/command/container/testdata/container-list-with-config-format.golden

@@ -1,2 +0,0 @@
-c1 busybox:latest some.label=value
-c2 busybox:latest foo=bar

components/cli/cli/command/container/testdata/container-list-with-format.golden

@@ -1,2 +0,0 @@
-c1 busybox:latest some.label=value
-c2 busybox:latest foo=bar

components/cli/cli/command/container/testdata/container-list-without-format-no-trunc.golden

@@ -1,3 +0,0 @@
-CONTAINER ID        IMAGE               COMMAND             CREATED                  STATUS              PORTS               NAMES
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second                             c1
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second                             c2,foo/bar

components/cli/cli/command/container/testdata/container-list-without-format.golden

@@ -1,6 +0,0 @@
-CONTAINER ID        IMAGE               COMMAND             CREATED                  STATUS              PORTS                NAMES
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second                              c1
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second                              c2
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second         80-82/tcp            c3
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second         81/udp               c4
-container_id        busybox:latest      "top"               Less than a second ago   Up 1 second         8.8.8.8:82->82/tcp   c5

components/cli/cli/command/container/utils.go

@@ -37,12 +37,7 @@ func waitExitOrRemoved(ctx context.Context, dockerCli command.Cli, containerID s
 	go func() {
 		select {
 		case result := <-resultC:
-			if result.Error != nil {
-				logrus.Errorf("Error waiting for container: %v", result.Error.Message)
-				statusC <- 125
-			} else {
-				statusC <- int(result.StatusCode)
-			}
+			statusC <- int(result.StatusCode)
 		case err := <-errC:
 			logrus.Errorf("error waiting for container: %v", err)
 			statusC <- 125

components/cli/cli/command/container/utils_test.go

@@ -1,70 +0,0 @@
-package container
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/docker/api"
-	"github.com/docker/docker/api/types/container"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/pkg/errors"
-	"golang.org/x/net/context"
-)
-
-func waitFn(cid string) (<-chan container.ContainerWaitOKBody, <-chan error) {
-	resC := make(chan container.ContainerWaitOKBody)
-	errC := make(chan error, 1)
-	var res container.ContainerWaitOKBody
-
-	go func() {
-		switch {
-		case strings.Contains(cid, "exit-code-42"):
-			res.StatusCode = 42
-			resC <- res
-		case strings.Contains(cid, "non-existent"):
-			err := errors.Errorf("No such container: %v", cid)
-			errC <- err
-		case strings.Contains(cid, "wait-error"):
-			res.Error = &container.ContainerWaitOKBodyError{Message: "removal failed"}
-			resC <- res
-		default:
-			// normal exit
-			resC <- res
-		}
-	}()
-
-	return resC, errC
-}
-
-func TestWaitExitOrRemoved(t *testing.T) {
-	testcases := []struct {
-		cid      string
-		exitCode int
-	}{
-		{
-			cid:      "normal-container",
-			exitCode: 0,
-		},
-		{
-			cid:      "give-me-exit-code-42",
-			exitCode: 42,
-		},
-		{
-			cid:      "i-want-a-wait-error",
-			exitCode: 125,
-		},
-		{
-			cid:      "non-existent-container-id",
-			exitCode: 125,
-		},
-	}
-
-	client := test.NewFakeCli(&fakeClient{waitFunc: waitFn, Version: api.DefaultVersion})
-	for _, testcase := range testcases {
-		statusC := waitExitOrRemoved(context.Background(), client, testcase.cid, true)
-		exitCode := <-statusC
-		assert.Check(t, is.Equal(testcase.exitCode, exitCode))
-	}
-}

components/cli/cli/command/formatter/checkpoint_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCheckpointContextFormatWrite(t *testing.T) {
@@ -46,7 +46,10 @@ checkpoint-3:
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
 		err := CheckpointWrite(testcase.context, checkpoints)
-		assert.NilError(t, err)
-		assert.Equal(t, out.String(), testcase.expected)
+		if err != nil {
+			assert.Error(t, err, testcase.expected)
+		} else {
+			assert.Equal(t, out.String(), testcase.expected)
+		}
 	}
 }

components/cli/cli/command/formatter/config_test.go

@@ -6,8 +6,7 @@ import (
 	"time"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestConfigContextFormatWrite(t *testing.T) {
@@ -56,9 +55,9 @@ id_rsa
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
 		if err := ConfigWrite(testcase.context, configs); err != nil {
-			assert.ErrorContains(t, err, testcase.expected)
+			assert.Error(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(out.String(), testcase.expected))
+			assert.Equal(t, out.String(), testcase.expected)
 		}
 	}
 }

components/cli/cli/command/formatter/container_test.go

@@ -10,9 +10,9 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestContainerPsContext(t *testing.T) {
@@ -244,9 +244,9 @@ size: 0B
 		testcase.context.Output = out
 		err := ContainerWrite(testcase.context, containers)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -305,7 +305,7 @@ func TestContainerContextWriteWithNoContainers(t *testing.T) {
 
 	for _, context := range contexts {
 		ContainerWrite(context.context, containers)
-		assert.Check(t, is.Equal(context.expected, out.String()))
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}
@@ -359,8 +359,8 @@ func TestContainerContextWriteJSON(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var m map[string]interface{}
 		err := json.Unmarshal([]byte(line), &m)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.DeepEqual(expectedJSONs[i], m), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, expectedJSONs[i], m, msg)
 	}
 }
 
@@ -378,8 +378,8 @@ func TestContainerContextWriteJSONField(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var s string
 		err := json.Unmarshal([]byte(line), &s)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.Equal(containers[i].ID, s), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, containers[i].ID, s, msg)
 	}
 }
 
@@ -642,17 +642,14 @@ func TestDisplayablePorts(t *testing.T) {
 					PublicPort:  1024,
 					PrivatePort: 80,
 					Type:        "udp",
-				}, {
-					PrivatePort: 12345,
-					Type:        "sctp",
 				},
 			},
-			"80/tcp, 80/udp, 1024/tcp, 1024/udp, 12345/sctp, 1.1.1.1:1024->80/tcp, 1.1.1.1:1024->80/udp, 2.1.1.1:1024->80/tcp, 2.1.1.1:1024->80/udp, 1.1.1.1:80->1024/tcp, 1.1.1.1:80->1024/udp, 2.1.1.1:80->1024/tcp, 2.1.1.1:80->1024/udp",
+			"80/tcp, 80/udp, 1024/tcp, 1024/udp, 1.1.1.1:1024->80/tcp, 1.1.1.1:1024->80/udp, 2.1.1.1:1024->80/tcp, 2.1.1.1:1024->80/udp, 1.1.1.1:80->1024/tcp, 1.1.1.1:80->1024/udp, 2.1.1.1:80->1024/tcp, 2.1.1.1:80->1024/udp",
 		},
 	}
 
 	for _, port := range cases {
 		actual := DisplayablePorts(port.ports)
-		assert.Check(t, is.Equal(port.expected, actual))
+		assert.Equal(t, port.expected, actual)
 	}
 }

components/cli/cli/command/formatter/custom_test.go

@@ -4,8 +4,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func compareMultipleValues(t *testing.T, value, expected string) {
@@ -24,5 +23,5 @@ func compareMultipleValues(t *testing.T, value, expected string) {
 		keyval := strings.Split(expected, "=")
 		expMap[keyval[0]] = keyval[1]
 	}
-	assert.Check(t, is.DeepEqual(expMap, entriesMap))
+	assert.Equal(t, expMap, entriesMap)
 }

components/cli/cli/command/formatter/diff_test.go

@@ -6,8 +6,7 @@ import (
 
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDiffContextFormatWrite(t *testing.T) {
@@ -52,9 +51,9 @@ D: /usr/app/old_app.js
 		testcase.context.Output = out
 		err := DiffWrite(testcase.context, diffs)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }

components/cli/cli/command/formatter/disk_usage_test.go

@@ -4,9 +4,8 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDiskUsageContextFormatWrite(t *testing.T) {
@@ -102,9 +101,9 @@ Build Cache                                                 0B
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
 		if err := testcase.context.Write(); err != nil {
-			assert.Check(t, is.Equal(testcase.expected, err.Error()))
+			assert.Equal(t, testcase.expected, err.Error())
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }

components/cli/cli/command/formatter/displayutils_test.go

@@ -3,8 +3,7 @@ package formatter
 import (
 	"testing"
 
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestEllipsis(t *testing.T) {
@@ -26,6 +25,6 @@ func TestEllipsis(t *testing.T) {
 	}
 
 	for _, testcase := range testcases {
-		assert.Check(t, is.Equal(testcase.expected, Ellipsis(testcase.source, testcase.width)))
+		assert.Equal(t, testcase.expected, Ellipsis(testcase.source, testcase.width))
 	}
 }

components/cli/cli/command/formatter/history_test.go

@@ -1,16 +1,16 @@
 package formatter
 
 import (
-	"bytes"
 	"strconv"
 	"strings"
 	"testing"
 	"time"
 
+	"bytes"
+
 	"github.com/docker/docker/api/types/image"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 type historyCase struct {
@@ -50,7 +50,6 @@ func TestHistoryContext_ID(t *testing.T) {
 }
 
 func TestHistoryContext_CreatedSince(t *testing.T) {
-	dateStr := "2009-11-10T23:00:00Z"
 	var ctx historyContext
 	cases := []historyCase{
 		{
@@ -65,7 +64,7 @@ func TestHistoryContext_CreatedSince(t *testing.T) {
 				h:     image.HistoryResponseItem{Created: time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC).Unix()},
 				trunc: false,
 				human: false,
-			}, dateStr, ctx.CreatedSince,
+			}, "2009-11-10T23:00:00Z", ctx.CreatedSince,
 		},
 	}
 
@@ -219,7 +218,7 @@ imageID4            24 hours ago        /bin/bash grep
 
 	for _, context := range contexts {
 		HistoryWrite(context.context, true, histories)
-		assert.Check(t, is.Equal(context.expected, out.String()))
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}

components/cli/cli/command/formatter/image_test.go

@@ -9,8 +9,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestImageContext(t *testing.T) {
@@ -84,7 +83,7 @@ func TestImageContext(t *testing.T) {
 		if strings.Contains(v, ",") {
 			compareMultipleValues(t, v, c.expValue)
 		} else {
-			assert.Check(t, is.Equal(c.expValue, v))
+			assert.Equal(t, c.expValue, v)
 		}
 	}
 }
@@ -294,9 +293,9 @@ image_id: imageID3
 		testcase.context.Output = out
 		err := ImageWrite(testcase.context, images)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -349,7 +348,7 @@ func TestImageContextWriteWithNoImage(t *testing.T) {
 
 	for _, context := range contexts {
 		ImageWrite(context.context, images)
-		assert.Check(t, is.Equal(context.expected, out.String()))
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}

components/cli/cli/command/formatter/network_test.go

@@ -10,8 +10,8 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNetworkContext(t *testing.T) {
@@ -162,9 +162,9 @@ foobar_bar 2017-01-01 00:00:00 +0000 UTC
 		testcase.context.Output = out
 		err := NetworkWrite(testcase.context, networks)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -188,8 +188,8 @@ func TestNetworkContextWriteJSON(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var m map[string]interface{}
 		err := json.Unmarshal([]byte(line), &m)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.DeepEqual(expectedJSONs[i], m), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, expectedJSONs[i], m, msg)
 	}
 }
 
@@ -207,7 +207,7 @@ func TestNetworkContextWriteJSONField(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var s string
 		err := json.Unmarshal([]byte(line), &s)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.Equal(networks[i].ID, s), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, networks[i].ID, s, msg)
 	}
 }

components/cli/cli/command/formatter/node.go

@@ -14,7 +14,7 @@ import (
 )
 
 const (
-	defaultNodeTableFormat           = "table {{.ID}} {{if .Self}}*{{else}} {{ end }}\t{{.Hostname}}\t{{.Status}}\t{{.Availability}}\t{{.ManagerStatus}}\t{{.EngineVersion}}"
+	defaultNodeTableFormat           = "table {{.ID}} {{if .Self}}*{{else}} {{ end }}\t{{.Hostname}}\t{{.Status}}\t{{.Availability}}\t{{.ManagerStatus}}"
 	nodeInspectPrettyTemplate Format = `ID:			{{.ID}}
 {{- if .Name }}
 Name:			{{.Name}}
@@ -75,7 +75,6 @@ TLS Info:
 	hostnameHeader      = "HOSTNAME"
 	availabilityHeader  = "AVAILABILITY"
 	managerStatusHeader = "MANAGER STATUS"
-	engineVersionHeader = "ENGINE VERSION"
 	tlsStatusHeader     = "TLS STATUS"
 )
 
@@ -116,7 +115,6 @@ func NodeWrite(ctx Context, nodes []swarm.Node, info types.Info) error {
 		"Status":        statusHeader,
 		"Availability":  availabilityHeader,
 		"ManagerStatus": managerStatusHeader,
-		"EngineVersion": engineVersionHeader,
 		"TLSStatus":     tlsStatusHeader,
 	}
 	nodeCtx := nodeContext{}
@@ -178,10 +176,6 @@ func (c *nodeContext) TLSStatus() string {
 	return "Needs Rotation"
 }
 
-func (c *nodeContext) EngineVersion() string {
-	return c.n.Description.Engine.EngineVersion
-}
-
 // NodeInspectWrite renders the context for a list of nodes
 func NodeInspectWrite(ctx Context, refs []string, getRef inspect.GetRefFunc) error {
 	if ctx.Format != nodeInspectPrettyTemplate {

components/cli/cli/command/formatter/node_test.go

@@ -10,8 +10,8 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNodeContext(t *testing.T) {
@@ -74,10 +74,10 @@ func TestNodeContextWrite(t *testing.T) {
 		// Table format
 		{
 			context: Context{Format: NewNodeFormat("table", false)},
-			expected: `ID                  HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
-nodeID1             foobar_baz          Foo                 Drain               Leader              18.03.0-ce
-nodeID2             foobar_bar          Bar                 Active              Reachable           1.2.3
-nodeID3             foobar_boo          Boo                 Active                                  ` + "\n", // (to preserve whitespace)
+			expected: `ID                  HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS
+nodeID1             foobar_baz          Foo                 Drain               Leader
+nodeID2             foobar_bar          Bar                 Active              Reachable
+nodeID3             foobar_boo          Boo                 Active              ` + "\n", // (to preserve whitespace)
 			clusterInfo: swarm.ClusterInfo{TLSInfo: swarm.TLSInfo{TrustRoot: "hi"}},
 		},
 		{
@@ -172,7 +172,6 @@ foobar_boo  Unknown
 				Description: swarm.NodeDescription{
 					Hostname: "foobar_baz",
 					TLSInfo:  swarm.TLSInfo{TrustRoot: "no"},
-					Engine:   swarm.EngineDescription{EngineVersion: "18.03.0-ce"},
 				},
 				Status:        swarm.NodeStatus{State: swarm.NodeState("foo")},
 				Spec:          swarm.NodeSpec{Availability: swarm.NodeAvailability("drain")},
@@ -183,7 +182,6 @@ foobar_boo  Unknown
 				Description: swarm.NodeDescription{
 					Hostname: "foobar_bar",
 					TLSInfo:  swarm.TLSInfo{TrustRoot: "hi"},
-					Engine:   swarm.EngineDescription{EngineVersion: "1.2.3"},
 				},
 				Status: swarm.NodeStatus{State: swarm.NodeState("bar")},
 				Spec:   swarm.NodeSpec{Availability: swarm.NodeAvailability("active")},
@@ -203,9 +201,9 @@ foobar_boo  Unknown
 		testcase.context.Output = out
 		err := NodeWrite(testcase.context, nodes, types.Info{Swarm: swarm.Info{Cluster: &testcase.clusterInfo}})
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -217,17 +215,17 @@ func TestNodeContextWriteJSON(t *testing.T) {
 	}{
 		{
 			expected: []map[string]interface{}{
-				{"Availability": "", "Hostname": "foobar_baz", "ID": "nodeID1", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Unknown", "EngineVersion": "1.2.3"},
-				{"Availability": "", "Hostname": "foobar_bar", "ID": "nodeID2", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Unknown", "EngineVersion": ""},
-				{"Availability": "", "Hostname": "foobar_boo", "ID": "nodeID3", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Unknown", "EngineVersion": "18.03.0-ce"},
+				{"Availability": "", "Hostname": "foobar_baz", "ID": "nodeID1", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Unknown"},
+				{"Availability": "", "Hostname": "foobar_bar", "ID": "nodeID2", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Unknown"},
+				{"Availability": "", "Hostname": "foobar_boo", "ID": "nodeID3", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Unknown"},
 			},
 			info: types.Info{},
 		},
 		{
 			expected: []map[string]interface{}{
-				{"Availability": "", "Hostname": "foobar_baz", "ID": "nodeID1", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Ready", "EngineVersion": "1.2.3"},
-				{"Availability": "", "Hostname": "foobar_bar", "ID": "nodeID2", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Needs Rotation", "EngineVersion": ""},
-				{"Availability": "", "Hostname": "foobar_boo", "ID": "nodeID3", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Unknown", "EngineVersion": "18.03.0-ce"},
+				{"Availability": "", "Hostname": "foobar_baz", "ID": "nodeID1", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Ready"},
+				{"Availability": "", "Hostname": "foobar_bar", "ID": "nodeID2", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Needs Rotation"},
+				{"Availability": "", "Hostname": "foobar_boo", "ID": "nodeID3", "ManagerStatus": "", "Status": "", "Self": false, "TLSStatus": "Unknown"},
 			},
 			info: types.Info{
 				Swarm: swarm.Info{
@@ -242,9 +240,9 @@ func TestNodeContextWriteJSON(t *testing.T) {
 
 	for _, testcase := range cases {
 		nodes := []swarm.Node{
-			{ID: "nodeID1", Description: swarm.NodeDescription{Hostname: "foobar_baz", TLSInfo: swarm.TLSInfo{TrustRoot: "hi"}, Engine: swarm.EngineDescription{EngineVersion: "1.2.3"}}},
+			{ID: "nodeID1", Description: swarm.NodeDescription{Hostname: "foobar_baz", TLSInfo: swarm.TLSInfo{TrustRoot: "hi"}}},
 			{ID: "nodeID2", Description: swarm.NodeDescription{Hostname: "foobar_bar", TLSInfo: swarm.TLSInfo{TrustRoot: "no"}}},
-			{ID: "nodeID3", Description: swarm.NodeDescription{Hostname: "foobar_boo", Engine: swarm.EngineDescription{EngineVersion: "18.03.0-ce"}}},
+			{ID: "nodeID3", Description: swarm.NodeDescription{Hostname: "foobar_boo"}},
 		}
 		out := bytes.NewBufferString("")
 		err := NodeWrite(Context{Format: "{{json .}}", Output: out}, nodes, testcase.info)
@@ -255,8 +253,8 @@ func TestNodeContextWriteJSON(t *testing.T) {
 			msg := fmt.Sprintf("Output: line %d: %s", i, line)
 			var m map[string]interface{}
 			err := json.Unmarshal([]byte(line), &m)
-			assert.NilError(t, err, msg)
-			assert.Check(t, is.DeepEqual(testcase.expected[i], m), msg)
+			require.NoError(t, err, msg)
+			assert.Equal(t, testcase.expected[i], m, msg)
 		}
 	}
 }
@@ -275,8 +273,8 @@ func TestNodeContextWriteJSONField(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var s string
 		err := json.Unmarshal([]byte(line), &s)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.Equal(nodes[i].ID, s), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, nodes[i].ID, s, msg)
 	}
 }
 
@@ -344,5 +342,5 @@ data
  Issuer Subject:	c3ViamVjdA==
  Issuer Public Key:	cHViS2V5
 `
-	assert.Check(t, is.Equal(expected, out.String()))
+	assert.Equal(t, expected, out.String())
 }

components/cli/cli/command/formatter/plugin_test.go

@@ -8,8 +8,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestPluginContext(t *testing.T) {
@@ -132,9 +131,9 @@ foobar_bar
 		testcase.context.Output = out
 		err := PluginWrite(testcase.context, plugins)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -159,7 +158,7 @@ func TestPluginContextWriteJSON(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &m); err != nil {
 			t.Fatal(err)
 		}
-		assert.Check(t, is.DeepEqual(expectedJSONs[i], m))
+		assert.Equal(t, expectedJSONs[i], m)
 	}
 }
 
@@ -178,6 +177,6 @@ func TestPluginContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Check(t, is.Equal(plugins[i].ID, s))
+		assert.Equal(t, plugins[i].ID, s)
 	}
 }

components/cli/cli/command/formatter/search_test.go

@@ -7,9 +7,8 @@ import (
 	"testing"
 
 	registrytypes "github.com/docker/docker/api/types/registry"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSearchContext(t *testing.T) {
@@ -155,9 +154,9 @@ result2 5
 		testcase.context.Output = out
 		err := SearchWrite(testcase.context, results, false, 0)
 		if err != nil {
-			assert.Check(t, is.ErrorContains(err, testcase.expected))
+			assert.Error(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(out.String(), testcase.expected))
+			assert.Equal(t, out.String(), testcase.expected)
 		}
 	}
 }
@@ -192,9 +191,9 @@ result2
 		testcase.context.Output = out
 		err := SearchWrite(testcase.context, results, true, 0)
 		if err != nil {
-			assert.Check(t, is.ErrorContains(err, testcase.expected))
+			assert.Error(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(out.String(), testcase.expected))
+			assert.Equal(t, out.String(), testcase.expected)
 		}
 	}
 }
@@ -227,9 +226,9 @@ result1
 		testcase.context.Output = out
 		err := SearchWrite(testcase.context, results, false, 6)
 		if err != nil {
-			assert.Check(t, is.ErrorContains(err, testcase.expected))
+			assert.Error(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(out.String(), testcase.expected))
+			assert.Equal(t, out.String(), testcase.expected)
 		}
 	}
 }
@@ -255,7 +254,7 @@ func TestSearchContextWriteJSON(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &m); err != nil {
 			t.Fatal(err)
 		}
-		assert.Check(t, is.DeepEqual(m, expectedJSONs[i]))
+		assert.Equal(t, m, expectedJSONs[i])
 	}
 }
 
@@ -275,6 +274,6 @@ func TestSearchContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Check(t, is.Equal(s, results[i].Name))
+		assert.Equal(t, s, results[i].Name)
 	}
 }

components/cli/cli/command/formatter/secret_test.go

@@ -6,8 +6,7 @@ import (
 	"time"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSecretContextFormatWrite(t *testing.T) {
@@ -56,9 +55,9 @@ id_rsa
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
 		if err := SecretWrite(testcase.context, secrets); err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }

components/cli/cli/command/formatter/service.go

@@ -2,7 +2,6 @@ package formatter
 
 import (
 	"fmt"
-	"sort"
 	"strings"
 	"time"
 
@@ -521,95 +520,19 @@ func (c *serviceContext) Image() string {
 	return image
 }
 
-type portRange struct {
-	pStart   uint32
-	pEnd     uint32
-	tStart   uint32
-	tEnd     uint32
-	protocol swarm.PortConfigProtocol
-}
-
-func (pr portRange) String() string {
-	var (
-		pub string
-		tgt string
-	)
-
-	if pr.pEnd > pr.pStart {
-		pub = fmt.Sprintf("%d-%d", pr.pStart, pr.pEnd)
-	} else {
-		pub = fmt.Sprintf("%d", pr.pStart)
-	}
-	if pr.tEnd > pr.tStart {
-		tgt = fmt.Sprintf("%d-%d", pr.tStart, pr.tEnd)
-	} else {
-		tgt = fmt.Sprintf("%d", pr.tStart)
-	}
-	return fmt.Sprintf("*:%s->%s/%s", pub, tgt, pr.protocol)
-}
-
-// Ports formats published ports on the ingress network for output.
-//
-// Where possible, ranges are grouped to produce a compact output:
-// - multiple ports mapped to a single port (80->80, 81->80); is formatted as *:80-81->80
-// - multiple consecutive ports on both sides; (80->80, 81->81) are formatted as: *:80-81->80-81
-//
-// The above should not be grouped together, i.e.:
-// - 80->80, 81->81, 82->80 should be presented as : *:80-81->80-81, *:82->80
-//
-// TODO improve:
-// - combine non-consecutive ports mapped to a single port (80->80, 81->80, 84->80, 86->80, 87->80); to be printed as *:80-81,84,86-87->80
-// - combine tcp and udp mappings if their port-mapping is exactly the same (*:80-81->80-81/tcp+udp instead of *:80-81->80-81/tcp, *:80-81->80-81/udp)
 func (c *serviceContext) Ports() string {
 	if c.service.Endpoint.Ports == nil {
 		return ""
 	}
-
-	pr := portRange{}
 	ports := []string{}
-
-	sort.Sort(byProtocolAndPublishedPort(c.service.Endpoint.Ports))
-
-	for _, p := range c.service.Endpoint.Ports {
-		if p.PublishMode == swarm.PortConfigPublishModeIngress {
-			prIsRange := pr.tEnd != pr.tStart
-			tOverlaps := p.TargetPort <= pr.tEnd
-
-			// Start a new port-range if:
-			// - the protocol is different from the current port-range
-			// - published or target port are not consecutive to the current port-range
-			// - the current port-range is a _range_, and the target port overlaps with the current range's target-ports
-			if p.Protocol != pr.protocol || p.PublishedPort-pr.pEnd > 1 || p.TargetPort-pr.tEnd > 1 || prIsRange && tOverlaps {
-				// start a new port-range, and print the previous port-range (if any)
-				if pr.pStart > 0 {
-					ports = append(ports, pr.String())
-				}
-				pr = portRange{
-					pStart:   p.PublishedPort,
-					pEnd:     p.PublishedPort,
-					tStart:   p.TargetPort,
-					tEnd:     p.TargetPort,
-					protocol: p.Protocol,
-				}
-				continue
-			}
-			pr.pEnd = p.PublishedPort
-			pr.tEnd = p.TargetPort
+	for _, pConfig := range c.service.Endpoint.Ports {
+		if pConfig.PublishMode == swarm.PortConfigPublishModeIngress {
+			ports = append(ports, fmt.Sprintf("*:%d->%d/%s",
+				pConfig.PublishedPort,
+				pConfig.TargetPort,
+				pConfig.Protocol,
+			))
 		}
 	}
-	if pr.pStart > 0 {
-		ports = append(ports, pr.String())
-	}
-	return strings.Join(ports, ", ")
-}
-
-type byProtocolAndPublishedPort []swarm.PortConfig
-
-func (a byProtocolAndPublishedPort) Len() int      { return len(a) }
-func (a byProtocolAndPublishedPort) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a byProtocolAndPublishedPort) Less(i, j int) bool {
-	if a[i].Protocol == a[j].Protocol {
-		return a[i].PublishedPort < a[j].PublishedPort
-	}
-	return a[i].Protocol < a[j].Protocol
+	return strings.Join(ports, ",")
 }

components/cli/cli/command/formatter/service_test.go

@@ -8,9 +8,9 @@ import (
 	"testing"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestServiceContextWrite(t *testing.T) {
@@ -126,9 +126,9 @@ bar
 		testcase.context.Output = out
 		err := ServiceListWrite(testcase.context, services, info)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -192,8 +192,8 @@ func TestServiceContextWriteJSON(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var m map[string]interface{}
 		err := json.Unmarshal([]byte(line), &m)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.DeepEqual(expectedJSONs[i], m), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, expectedJSONs[i], m, msg)
 	}
 }
 func TestServiceContextWriteJSONField(t *testing.T) {
@@ -220,140 +220,7 @@ func TestServiceContextWriteJSONField(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var s string
 		err := json.Unmarshal([]byte(line), &s)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.Equal(services[i].Spec.Name, s), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, services[i].Spec.Name, s, msg)
 	}
 }
-
-func TestServiceContext_Ports(t *testing.T) {
-	c := serviceContext{
-		service: swarm.Service{
-			Endpoint: swarm.Endpoint{
-				Ports: []swarm.PortConfig{
-					{
-						Protocol:      "tcp",
-						TargetPort:    80,
-						PublishedPort: 81,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    80,
-						PublishedPort: 80,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    95,
-						PublishedPort: 95,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    90,
-						PublishedPort: 90,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    91,
-						PublishedPort: 91,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    92,
-						PublishedPort: 92,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    93,
-						PublishedPort: 93,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    94,
-						PublishedPort: 94,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "udp",
-						TargetPort:    95,
-						PublishedPort: 95,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "udp",
-						TargetPort:    90,
-						PublishedPort: 90,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "udp",
-						TargetPort:    96,
-						PublishedPort: 96,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "udp",
-						TargetPort:    91,
-						PublishedPort: 91,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "udp",
-						TargetPort:    92,
-						PublishedPort: 92,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "udp",
-						TargetPort:    93,
-						PublishedPort: 93,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "udp",
-						TargetPort:    94,
-						PublishedPort: 94,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    60,
-						PublishedPort: 60,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    61,
-						PublishedPort: 61,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "tcp",
-						TargetPort:    61,
-						PublishedPort: 62,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "sctp",
-						TargetPort:    97,
-						PublishedPort: 97,
-						PublishMode:   "ingress",
-					},
-					{
-						Protocol:      "sctp",
-						TargetPort:    98,
-						PublishedPort: 98,
-						PublishMode:   "ingress",
-					},
-				},
-			},
-		},
-	}
-
-	assert.Check(t, is.Equal("*:97-98->97-98/sctp, *:60-61->60-61/tcp, *:62->61/tcp, *:80-81->80/tcp, *:90-95->90-95/tcp, *:90-96->90-96/udp", c.Ports()))
-}

components/cli/cli/command/formatter/stack_test.go

@@ -4,8 +4,7 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestStackContextWrite(t *testing.T) {
@@ -57,9 +56,9 @@ bar
 		testcase.context.Output = out
 		err := StackWrite(testcase.context, stacks)
 		if err != nil {
-			assert.Check(t, is.ErrorContains(err, testcase.expected))
+			assert.Error(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(out.String(), testcase.expected))
+			assert.Equal(t, out.String(), testcase.expected)
 		}
 	}
 }

components/cli/cli/command/formatter/stats_test.go

@@ -5,8 +5,7 @@ import (
 	"testing"
 
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestContainerStatsContext(t *testing.T) {
@@ -117,9 +116,9 @@ container2  --
 		te.context.Output = &out
 		err := ContainerStatsWrite(te.context, stats, "linux", false)
 		if err != nil {
-			assert.Error(t, err, te.expected)
+			assert.EqualError(t, err, te.expected)
 		} else {
-			assert.Check(t, is.Equal(te.expected, out.String()))
+			assert.Equal(t, te.expected, out.String())
 		}
 	}
 }
@@ -183,9 +182,9 @@ container2  --  --
 		te.context.Output = &out
 		err := ContainerStatsWrite(te.context, stats, "windows", false)
 		if err != nil {
-			assert.Error(t, err, te.expected)
+			assert.EqualError(t, err, te.expected)
 		} else {
-			assert.Check(t, is.Equal(te.expected, out.String()))
+			assert.Equal(t, te.expected, out.String())
 		}
 	}
 }
@@ -222,7 +221,7 @@ func TestContainerStatsContextWriteWithNoStats(t *testing.T) {
 
 	for _, context := range contexts {
 		ContainerStatsWrite(context.context, []StatsEntry{}, "linux", false)
-		assert.Check(t, is.Equal(context.expected, out.String()))
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}
@@ -260,7 +259,7 @@ func TestContainerStatsContextWriteWithNoStatsWindows(t *testing.T) {
 
 	for _, context := range contexts {
 		ContainerStatsWrite(context.context, []StatsEntry{}, "windows", false)
-		assert.Check(t, is.Equal(context.expected, out.String()))
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}
@@ -294,7 +293,7 @@ func TestContainerStatsContextWriteTrunc(t *testing.T) {
 
 	for _, context := range contexts {
 		ContainerStatsWrite(context.context, []StatsEntry{{ID: "b95a83497c9161c9b444e3d70e1a9dfba0c1840d41720e146a95a08ebf938afc"}}, "linux", context.trunc)
-		assert.Check(t, is.Equal(context.expected, out.String()))
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}

components/cli/cli/command/formatter/task_test.go

@@ -7,9 +7,8 @@ import (
 	"testing"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestTaskContextWrite(t *testing.T) {
@@ -75,9 +74,9 @@ foobar_bar foo2
 		testcase.context.Output = out
 		err := TaskWrite(testcase.context, tasks, names, nodes)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -101,6 +100,6 @@ func TestTaskContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Check(t, is.Equal(tasks[i].ID, s))
+		assert.Equal(t, tasks[i].ID, s)
 	}
 }

components/cli/cli/command/formatter/trust_test.go

@@ -5,8 +5,7 @@ import (
 	"testing"
 
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestTrustTag(t *testing.T) {
@@ -127,9 +126,9 @@ tag3                bbbbbbbb
 		testcase.context.Output = out
 		err := TrustTagWrite(testcase.context, signedTags)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -153,8 +152,8 @@ func TestTrustTagContextEmptyWrite(t *testing.T) {
 	out := bytes.NewBufferString("")
 	emptyCase.context.Output = out
 	err := TrustTagWrite(emptyCase.context, emptySignedTags)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(emptyCase.expected, out.String()))
+	assert.NoError(t, err)
+	assert.Equal(t, emptyCase.expected, out.String())
 }
 
 func TestSignerInfoContextEmptyWrite(t *testing.T) {
@@ -172,8 +171,8 @@ func TestSignerInfoContextEmptyWrite(t *testing.T) {
 	out := bytes.NewBufferString("")
 	emptyCase.context.Output = out
 	err := SignerInfoWrite(emptyCase.context, emptySignerInfo)
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal(emptyCase.expected, out.String()))
+	assert.NoError(t, err)
+	assert.Equal(t, emptyCase.expected, out.String())
 }
 
 func TestSignerInfoContextWrite(t *testing.T) {
@@ -231,9 +230,9 @@ eve                 foobarbazquxquux, key31, key32
 		testcase.context.Output = out
 		err := SignerInfoWrite(testcase.context, signerInfo)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }

components/cli/cli/command/formatter/volume_test.go

@@ -9,8 +9,8 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestVolumeContext(t *testing.T) {
@@ -133,9 +133,9 @@ foobar_bar
 		testcase.context.Output = out
 		err := VolumeWrite(testcase.context, volumes)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Check(t, is.Equal(testcase.expected, out.String()))
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -158,8 +158,8 @@ func TestVolumeContextWriteJSON(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var m map[string]interface{}
 		err := json.Unmarshal([]byte(line), &m)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.DeepEqual(expectedJSONs[i], m), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, expectedJSONs[i], m, msg)
 	}
 }
 
@@ -177,7 +177,7 @@ func TestVolumeContextWriteJSONField(t *testing.T) {
 		msg := fmt.Sprintf("Output: line %d: %s", i, line)
 		var s string
 		err := json.Unmarshal([]byte(line), &s)
-		assert.NilError(t, err, msg)
-		assert.Check(t, is.Equal(volumes[i].Name, s), msg)
+		require.NoError(t, err, msg)
+		assert.Equal(t, volumes[i].Name, s, msg)
 	}
 }

components/cli/cli/command/idresolver/idresolver_test.go

@@ -4,11 +4,10 @@ import (
 	"testing"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/cli/internal/test/builders"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
 )
 
@@ -22,7 +21,7 @@ func TestResolveError(t *testing.T) {
 	idResolver := New(cli, false)
 	_, err := idResolver.Resolve(context.Background(), struct{}{}, "nodeID")
 
-	assert.Error(t, err, "unsupported type")
+	assert.EqualError(t, err, "unsupported type")
 }
 
 func TestResolveWithNoResolveOption(t *testing.T) {
@@ -41,9 +40,9 @@ func TestResolveWithNoResolveOption(t *testing.T) {
 	idResolver := New(cli, true)
 	id, err := idResolver.Resolve(context.Background(), swarm.Node{}, "nodeID")
 
-	assert.NilError(t, err)
-	assert.Check(t, is.Equal("nodeID", id))
-	assert.Check(t, !resolved)
+	assert.NoError(t, err)
+	assert.Equal(t, "nodeID", id)
+	assert.False(t, resolved)
 }
 
 func TestResolveWithCache(t *testing.T) {
@@ -60,11 +59,11 @@ func TestResolveWithCache(t *testing.T) {
 	ctx := context.Background()
 	for i := 0; i < 2; i++ {
 		id, err := idResolver.Resolve(ctx, swarm.Node{}, "nodeID")
-		assert.NilError(t, err)
-		assert.Check(t, is.Equal("node-foo", id))
+		assert.NoError(t, err)
+		assert.Equal(t, "node-foo", id)
 	}
 
-	assert.Check(t, is.Equal(1, inspectCounter))
+	assert.Equal(t, 1, inspectCounter)
 }
 
 func TestResolveNode(t *testing.T) {
@@ -104,8 +103,8 @@ func TestResolveNode(t *testing.T) {
 		idResolver := New(cli, false)
 		id, err := idResolver.Resolve(ctx, swarm.Node{}, tc.nodeID)
 
-		assert.NilError(t, err)
-		assert.Check(t, is.Equal(tc.expectedID, id))
+		assert.NoError(t, err)
+		assert.Equal(t, tc.expectedID, id)
 	}
 }
 
@@ -139,7 +138,7 @@ func TestResolveService(t *testing.T) {
 		idResolver := New(cli, false)
 		id, err := idResolver.Resolve(ctx, swarm.Service{}, tc.serviceID)
 
-		assert.NilError(t, err)
-		assert.Check(t, is.Equal(tc.expectedID, id))
+		assert.NoError(t, err)
+		assert.Equal(t, tc.expectedID, id)
 	}
 }

components/cli/cli/command/image/build.go

@@ -9,10 +9,8 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
-	"path/filepath"
 	"regexp"
 	"runtime"
-	"strings"
 
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
@@ -67,7 +65,6 @@ type buildOptions struct {
 	imageIDFile    string
 	stream         bool
 	platform       string
-	untrusted      bool
 }
 
 // dockerfileFromStdin returns true when the user specified that the Dockerfile
@@ -138,7 +135,7 @@ func NewBuildCommand(dockerCli command.Cli) *cobra.Command {
 	flags.StringVar(&options.target, "target", "", "Set the target build stage to build.")
 	flags.StringVar(&options.imageIDFile, "iidfile", "", "Write the image ID to the file")
 
-	command.AddTrustVerificationFlags(flags, &options.untrusted, dockerCli.ContentTrustEnabled())
+	command.AddTrustVerificationFlags(flags)
 	command.AddPlatformFlag(flags, &options.platform)
 
 	flags.BoolVar(&options.squash, "squash", false, "Squash newly built layers into a single new layer")
@@ -209,14 +206,6 @@ func runBuild(dockerCli command.Cli, options buildOptions) error {
 		buildCtx, relDockerfile, err = build.GetContextFromReader(dockerCli.In(), options.dockerfileName)
 	case isLocalDir(specifiedContext):
 		contextDir, relDockerfile, err = build.GetContextFromLocalDir(specifiedContext, options.dockerfileName)
-		if err == nil && strings.HasPrefix(relDockerfile, ".."+string(filepath.Separator)) {
-			// Dockerfile is outside of build-context; read the Dockerfile and pass it as dockerfileCtx
-			dockerfileCtx, err = os.Open(options.dockerfileName)
-			if err != nil {
-				return errors.Errorf("unable to open Dockerfile: %v", err)
-			}
-			defer dockerfileCtx.Close()
-		}
 	case urlutil.IsGitURL(specifiedContext):
 		tempDir, relDockerfile, err = build.GetContextFromGitURL(specifiedContext, options.dockerfileName)
 	case urlutil.IsURL(specifiedContext):
@@ -264,7 +253,7 @@ func runBuild(dockerCli command.Cli, options buildOptions) error {
 		}
 	}
 
-	// replace Dockerfile if it was added from stdin or a file outside the build-context, and there is archive context
+	// replace Dockerfile if it was added from stdin and there is archive context
 	if dockerfileCtx != nil && buildCtx != nil {
 		buildCtx, relDockerfile, err = build.AddDockerfileToBuildContext(dockerfileCtx, buildCtx)
 		if err != nil {
@@ -272,7 +261,7 @@ func runBuild(dockerCli command.Cli, options buildOptions) error {
 		}
 	}
 
-	// if streaming and Dockerfile was not from stdin then read from file
+	// if streaming and dockerfile was not from stdin then read from file
 	// to the same reader that is usually stdin
 	if options.stream && dockerfileCtx == nil {
 		dockerfileCtx, err = os.Open(relDockerfile)
@@ -286,7 +275,7 @@ func runBuild(dockerCli command.Cli, options buildOptions) error {
 	defer cancel()
 
 	var resolvedTags []*resolvedTag
-	if !options.untrusted {
+	if command.IsTrusted() {
 		translator := func(ctx context.Context, ref reference.NamedTagged) (reference.Canonical, error) {
 			return TrustedReference(ctx, dockerCli, ref, nil)
 		}
@@ -294,10 +283,10 @@ func runBuild(dockerCli command.Cli, options buildOptions) error {
 		if buildCtx != nil {
 			// Wrap the tar archive to replace the Dockerfile entry with the rewritten
 			// Dockerfile which uses trusted pulls.
-			buildCtx = replaceDockerfileForContentTrust(ctx, buildCtx, relDockerfile, translator, &resolvedTags)
+			buildCtx = replaceDockerfileTarWrapper(ctx, buildCtx, relDockerfile, translator, &resolvedTags)
 		} else if dockerfileCtx != nil {
 			// if there was not archive context still do the possible replacements in Dockerfile
-			newDockerfile, _, err := rewriteDockerfileFromForContentTrust(ctx, dockerfileCtx, translator)
+			newDockerfile, _, err := rewriteDockerfileFrom(ctx, dockerfileCtx, translator)
 			if err != nil {
 				return err
 			}
@@ -461,7 +450,7 @@ func runBuild(dockerCli command.Cli, options buildOptions) error {
 			return err
 		}
 	}
-	if !options.untrusted {
+	if command.IsTrusted() {
 		// Since the build was successful, now we must tag any of the resolved
 		// images from the above Dockerfile rewrite.
 		for _, resolved := range resolvedTags {
@@ -500,12 +489,11 @@ type resolvedTag struct {
 	tagRef    reference.NamedTagged
 }
 
-// rewriteDockerfileFromForContentTrust rewrites the given Dockerfile by resolving images in
+// rewriteDockerfileFrom rewrites the given Dockerfile by resolving images in
 // "FROM <image>" instructions to a digest reference. `translator` is a
 // function that takes a repository name and tag reference and returns a
 // trusted digest reference.
-// This should be called *only* when content trust is enabled
-func rewriteDockerfileFromForContentTrust(ctx context.Context, dockerfile io.Reader, translator translatorFunc) (newDockerfile []byte, resolvedTags []*resolvedTag, err error) {
+func rewriteDockerfileFrom(ctx context.Context, dockerfile io.Reader, translator translatorFunc) (newDockerfile []byte, resolvedTags []*resolvedTag, err error) {
 	scanner := bufio.NewScanner(dockerfile)
 	buf := bytes.NewBuffer(nil)
 
@@ -522,7 +510,7 @@ func rewriteDockerfileFromForContentTrust(ctx context.Context, dockerfile io.Rea
 				return nil, nil, err
 			}
 			ref = reference.TagNameOnly(ref)
-			if ref, ok := ref.(reference.NamedTagged); ok {
+			if ref, ok := ref.(reference.NamedTagged); ok && command.IsTrusted() {
 				trustedRef, err := translator(ctx, ref)
 				if err != nil {
 					return nil, nil, err
@@ -545,10 +533,11 @@ func rewriteDockerfileFromForContentTrust(ctx context.Context, dockerfile io.Rea
 	return buf.Bytes(), resolvedTags, scanner.Err()
 }
 
-// replaceDockerfileForContentTrust wraps the given input tar archive stream and
-// uses the translator to replace the Dockerfile which uses a trusted reference.
-// Returns a new tar archive stream with the replaced Dockerfile.
-func replaceDockerfileForContentTrust(ctx context.Context, inputTarStream io.ReadCloser, dockerfileName string, translator translatorFunc, resolvedTags *[]*resolvedTag) io.ReadCloser {
+// replaceDockerfileTarWrapper wraps the given input tar archive stream and
+// replaces the entry with the given Dockerfile name with the contents of the
+// new Dockerfile. Returns a new tar archive stream with the replaced
+// Dockerfile.
+func replaceDockerfileTarWrapper(ctx context.Context, inputTarStream io.ReadCloser, dockerfileName string, translator translatorFunc, resolvedTags *[]*resolvedTag) io.ReadCloser {
 	pipeReader, pipeWriter := io.Pipe()
 	go func() {
 		tarReader := tar.NewReader(inputTarStream)
@@ -575,7 +564,7 @@ func replaceDockerfileForContentTrust(ctx context.Context, inputTarStream io.Rea
 				// generated from a directory on the local filesystem, the
 				// Dockerfile will only appear once in the archive.
 				var newDockerfile []byte
-				newDockerfile, *resolvedTags, err = rewriteDockerfileFromForContentTrust(ctx, content, translator)
+				newDockerfile, *resolvedTags, err = rewriteDockerfileFrom(ctx, content, translator)
 				if err != nil {
 					pipeWriter.CloseWithError(err)
 					return

components/cli/cli/command/image/build/context.go

@@ -167,10 +167,6 @@ func GetContextFromGitURL(gitURL, dockerfileName string) (string, string, error)
 		return "", "", err
 	}
 	relDockerfile, err := getDockerfileRelPath(absContextDir, dockerfileName)
-	if err == nil && strings.HasPrefix(relDockerfile, ".."+string(filepath.Separator)) {
-		return "", "", errors.Errorf("the Dockerfile (%s) must be within the build context", dockerfileName)
-	}
-
 	return absContextDir, relDockerfile, err
 }
 
@@ -322,6 +318,10 @@ func getDockerfileRelPath(absContextDir, givenDockerfile string) (string, error)
 		return "", errors.Errorf("unable to get relative Dockerfile path: %v", err)
 	}
 
+	if strings.HasPrefix(relDockerfile, ".."+string(filepath.Separator)) {
+		return "", errors.Errorf("the Dockerfile (%s) must be within the build context", givenDockerfile)
+	}
+
 	return relDockerfile, nil
 }
 

components/cli/cli/command/image/build/context_test.go

@@ -11,9 +11,10 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const dockerfileContents = "FROM busybox"
@@ -37,7 +38,7 @@ func testValidateContextDirectory(t *testing.T, prepare func(t *testing.T) (stri
 	defer cleanup()
 
 	err := ValidateContextDirectory(contextDir, excludes)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 }
 
 func TestGetContextFromLocalDirNoDockerfile(t *testing.T) {
@@ -45,7 +46,7 @@ func TestGetContextFromLocalDirNoDockerfile(t *testing.T) {
 	defer cleanup()
 
 	_, _, err := GetContextFromLocalDir(contextDir, "")
-	assert.ErrorContains(t, err, "Dockerfile")
+	testutil.ErrorContains(t, err, "Dockerfile")
 }
 
 func TestGetContextFromLocalDirNotExistingDir(t *testing.T) {
@@ -55,7 +56,7 @@ func TestGetContextFromLocalDirNotExistingDir(t *testing.T) {
 	fakePath := filepath.Join(contextDir, "fake")
 
 	_, _, err := GetContextFromLocalDir(fakePath, "")
-	assert.ErrorContains(t, err, "fake")
+	testutil.ErrorContains(t, err, "fake")
 }
 
 func TestGetContextFromLocalDirNotExistingDockerfile(t *testing.T) {
@@ -65,7 +66,7 @@ func TestGetContextFromLocalDirNotExistingDockerfile(t *testing.T) {
 	fakePath := filepath.Join(contextDir, "fake")
 
 	_, _, err := GetContextFromLocalDir(contextDir, fakePath)
-	assert.ErrorContains(t, err, "fake")
+	testutil.ErrorContains(t, err, "fake")
 }
 
 func TestGetContextFromLocalDirWithNoDirectory(t *testing.T) {
@@ -78,10 +79,10 @@ func TestGetContextFromLocalDirWithNoDirectory(t *testing.T) {
 	defer chdirCleanup()
 
 	absContextDir, relDockerfile, err := GetContextFromLocalDir(contextDir, "")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
-	assert.Check(t, is.Equal(contextDir, absContextDir))
-	assert.Check(t, is.Equal(DefaultDockerfileName, relDockerfile))
+	assert.Equal(t, contextDir, absContextDir)
+	assert.Equal(t, DefaultDockerfileName, relDockerfile)
 }
 
 func TestGetContextFromLocalDirWithDockerfile(t *testing.T) {
@@ -91,10 +92,10 @@ func TestGetContextFromLocalDirWithDockerfile(t *testing.T) {
 	createTestTempFile(t, contextDir, DefaultDockerfileName, dockerfileContents, 0777)
 
 	absContextDir, relDockerfile, err := GetContextFromLocalDir(contextDir, "")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
-	assert.Check(t, is.Equal(contextDir, absContextDir))
-	assert.Check(t, is.Equal(DefaultDockerfileName, relDockerfile))
+	assert.Equal(t, contextDir, absContextDir)
+	assert.Equal(t, DefaultDockerfileName, relDockerfile)
 }
 
 func TestGetContextFromLocalDirLocalFile(t *testing.T) {
@@ -129,10 +130,10 @@ func TestGetContextFromLocalDirWithCustomDockerfile(t *testing.T) {
 	createTestTempFile(t, contextDir, DefaultDockerfileName, dockerfileContents, 0777)
 
 	absContextDir, relDockerfile, err := GetContextFromLocalDir(contextDir, DefaultDockerfileName)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
-	assert.Check(t, is.Equal(contextDir, absContextDir))
-	assert.Check(t, is.Equal(DefaultDockerfileName, relDockerfile))
+	assert.Equal(t, contextDir, absContextDir)
+	assert.Equal(t, DefaultDockerfileName, relDockerfile)
 }
 
 func TestGetContextFromReaderString(t *testing.T) {
@@ -160,7 +161,7 @@ func TestGetContextFromReaderString(t *testing.T) {
 		t.Fatalf("Tar stream too long: %s", err)
 	}
 
-	assert.NilError(t, tarArchive.Close())
+	require.NoError(t, tarArchive.Close())
 
 	if dockerfileContents != contents {
 		t.Fatalf("Uncompressed tar archive does not equal: %s, got: %s", dockerfileContents, contents)
@@ -178,15 +179,15 @@ func TestGetContextFromReaderTar(t *testing.T) {
 	createTestTempFile(t, contextDir, DefaultDockerfileName, dockerfileContents, 0777)
 
 	tarStream, err := archive.Tar(contextDir, archive.Uncompressed)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	tarArchive, relDockerfile, err := GetContextFromReader(tarStream, DefaultDockerfileName)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	tarReader := tar.NewReader(tarArchive)
 
 	header, err := tarReader.Next()
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	if header.Name != DefaultDockerfileName {
 		t.Fatalf("Dockerfile name should be: %s, got: %s", DefaultDockerfileName, header.Name)
@@ -202,7 +203,7 @@ func TestGetContextFromReaderTar(t *testing.T) {
 		t.Fatalf("Tar stream too long: %s", err)
 	}
 
-	assert.NilError(t, tarArchive.Close())
+	require.NoError(t, tarArchive.Close())
 
 	if dockerfileContents != contents {
 		t.Fatalf("Uncompressed tar archive does not equal: %s, got: %s", dockerfileContents, contents)
@@ -242,8 +243,8 @@ func TestValidateContextDirectoryWithOneFileExcludes(t *testing.T) {
 // When an error occurs, it terminates the test.
 func createTestTempDir(t *testing.T, dir, prefix string) (string, func()) {
 	path, err := ioutil.TempDir(dir, prefix)
-	assert.NilError(t, err)
-	return path, func() { assert.NilError(t, os.RemoveAll(path)) }
+	require.NoError(t, err)
+	return path, func() { require.NoError(t, os.RemoveAll(path)) }
 }
 
 // createTestTempFile creates a temporary file within dir with specific contents and permissions.
@@ -251,7 +252,7 @@ func createTestTempDir(t *testing.T, dir, prefix string) (string, func()) {
 func createTestTempFile(t *testing.T, dir, filename, contents string, perm os.FileMode) string {
 	filePath := filepath.Join(dir, filename)
 	err := ioutil.WriteFile(filePath, []byte(contents), perm)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	return filePath
 }
 
@@ -261,9 +262,9 @@ func createTestTempFile(t *testing.T, dir, filename, contents string, perm os.Fi
 // When an error occurs, it terminates the test.
 func chdir(t *testing.T, dir string) func() {
 	workingDirectory, err := os.Getwd()
-	assert.NilError(t, err)
-	assert.NilError(t, os.Chdir(dir))
-	return func() { assert.NilError(t, os.Chdir(workingDirectory)) }
+	require.NoError(t, err)
+	require.NoError(t, os.Chdir(dir))
+	return func() { require.NoError(t, os.Chdir(workingDirectory)) }
 }
 
 func TestIsArchive(t *testing.T) {
@@ -294,6 +295,6 @@ func TestIsArchive(t *testing.T) {
 		},
 	}
 	for _, testcase := range testcases {
-		assert.Check(t, is.Equal(testcase.expected, IsArchive(testcase.header)), testcase.doc)
+		assert.Equal(t, testcase.expected, IsArchive(testcase.header), testcase.doc)
 	}
 }

components/cli/cli/command/image/build_linux_test.go

@@ -1,55 +0,0 @@
-//+build linux
-
-package image
-
-import (
-	"bytes"
-	"io"
-	"io/ioutil"
-	"syscall"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/pkg/archive"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/fs"
-	"golang.org/x/net/context"
-)
-
-func TestRunBuildResetsUidAndGidInContext(t *testing.T) {
-	dest := fs.NewDir(t, "test-build-context-dest")
-	defer dest.Remove()
-
-	fakeImageBuild := func(_ context.Context, context io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
-		assert.NilError(t, archive.Untar(context, dest.Path(), nil))
-
-		body := new(bytes.Buffer)
-		return types.ImageBuildResponse{Body: ioutil.NopCloser(body)}, nil
-	}
-	cli := test.NewFakeCli(&fakeClient{imageBuildFunc: fakeImageBuild})
-
-	dir := fs.NewDir(t, "test-build-context",
-		fs.WithFile("foo", "some content", fs.AsUser(65534, 65534)),
-		fs.WithFile("Dockerfile", `
-			FROM alpine:3.6
-			COPY foo bar /
-		`),
-	)
-	defer dir.Remove()
-
-	options := newBuildOptions()
-	options.context = dir.Path()
-	options.untrusted = true
-
-	err := runBuild(cli, options)
-	assert.NilError(t, err)
-
-	files, err := ioutil.ReadDir(dest.Path())
-	assert.NilError(t, err)
-	for _, fileInfo := range files {
-		assert.Check(t, is.Equal(uint32(0), fileInfo.Sys().(*syscall.Stat_t).Uid))
-		assert.Check(t, is.Equal(uint32(0), fileInfo.Sys().(*syscall.Stat_t).Gid))
-	}
-}

components/cli/cli/command/image/build_test.go

@@ -1,28 +1,65 @@
 package image
 
 import (
-	"archive/tar"
 	"bytes"
 	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"runtime"
 	"sort"
+	"syscall"
 	"testing"
 
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/internal/test"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/fs"
+	"github.com/gotestyourself/gotestyourself/skip"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"golang.org/x/net/context"
 )
 
+func TestRunBuildResetsUidAndGidInContext(t *testing.T) {
+	skip.IfCondition(t, runtime.GOOS == "windows", "uid and gid not relevant on windows")
+	dest := fs.NewDir(t, "test-build-context-dest")
+	defer dest.Remove()
+
+	fakeImageBuild := func(_ context.Context, context io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
+		assert.NoError(t, archive.Untar(context, dest.Path(), nil))
+
+		body := new(bytes.Buffer)
+		return types.ImageBuildResponse{Body: ioutil.NopCloser(body)}, nil
+	}
+	cli := test.NewFakeCli(&fakeClient{imageBuildFunc: fakeImageBuild})
+
+	dir := fs.NewDir(t, "test-build-context",
+		fs.WithFile("foo", "some content", fs.AsUser(65534, 65534)),
+		fs.WithFile("Dockerfile", `
+			FROM alpine:3.6
+			COPY foo bar /
+		`),
+	)
+	defer dir.Remove()
+
+	options := newBuildOptions()
+	options.context = dir.Path()
+
+	err := runBuild(cli, options)
+	require.NoError(t, err)
+
+	files, err := ioutil.ReadDir(dest.Path())
+	require.NoError(t, err)
+	for _, fileInfo := range files {
+		assert.Equal(t, uint32(0), fileInfo.Sys().(*syscall.Stat_t).Uid)
+		assert.Equal(t, uint32(0), fileInfo.Sys().(*syscall.Stat_t).Gid)
+	}
+}
 func TestRunBuildDockerfileFromStdinWithCompress(t *testing.T) {
 	dest, err := ioutil.TempDir("", "test-build-compress-dest")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	defer os.RemoveAll(dest)
 
 	var dockerfileName string
@@ -30,11 +67,11 @@ func TestRunBuildDockerfileFromStdinWithCompress(t *testing.T) {
 		buffer := new(bytes.Buffer)
 		tee := io.TeeReader(context, buffer)
 
-		assert.NilError(t, archive.Untar(tee, dest, nil))
+		assert.NoError(t, archive.Untar(tee, dest, nil))
 		dockerfileName = options.Dockerfile
 
 		header := buffer.Bytes()[:10]
-		assert.Check(t, is.Equal(archive.Gzip, archive.DetectCompression(header)))
+		assert.Equal(t, archive.Gzip, archive.DetectCompression(header))
 
 		body := new(bytes.Buffer)
 		return types.ImageBuildResponse{Body: ioutil.NopCloser(body)}, nil
@@ -48,7 +85,7 @@ func TestRunBuildDockerfileFromStdinWithCompress(t *testing.T) {
 	cli.SetIn(command.NewInStream(ioutil.NopCloser(dockerfile)))
 
 	dir, err := ioutil.TempDir("", "test-build-compress")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	defer os.RemoveAll(dir)
 
 	ioutil.WriteFile(filepath.Join(dir, "foo"), []byte("some content"), 0644)
@@ -57,85 +94,30 @@ func TestRunBuildDockerfileFromStdinWithCompress(t *testing.T) {
 	options.compress = true
 	options.dockerfileName = "-"
 	options.context = dir
-	options.untrusted = true
 
 	err = runBuild(cli, options)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	files, err := ioutil.ReadDir(dest)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	actual := []string{}
 	for _, fileInfo := range files {
 		actual = append(actual, fileInfo.Name())
 	}
 	sort.Strings(actual)
-	assert.Check(t, is.DeepEqual([]string{dockerfileName, ".dockerignore", "foo"}, actual))
-}
-
-func TestRunBuildDockerfileOutsideContext(t *testing.T) {
-	dir := fs.NewDir(t, t.Name(),
-		fs.WithFile("data", "data file"),
-	)
-	defer dir.Remove()
-
-	// Dockerfile outside of build-context
-	df := fs.NewFile(t, t.Name(),
-		fs.WithContent(`
-FROM FOOBAR
-COPY data /data
-		`),
-	)
-	defer df.Remove()
-
-	dest, err := ioutil.TempDir("", t.Name())
-	assert.NilError(t, err)
-	defer os.RemoveAll(dest)
-
-	var dockerfileName string
-	fakeImageBuild := func(_ context.Context, context io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
-		buffer := new(bytes.Buffer)
-		tee := io.TeeReader(context, buffer)
-
-		assert.NilError(t, archive.Untar(tee, dest, nil))
-		dockerfileName = options.Dockerfile
-
-		body := new(bytes.Buffer)
-		return types.ImageBuildResponse{Body: ioutil.NopCloser(body)}, nil
-	}
-
-	cli := test.NewFakeCli(&fakeClient{imageBuildFunc: fakeImageBuild})
-
-	options := newBuildOptions()
-	options.context = dir.Path()
-	options.dockerfileName = df.Path()
-	options.untrusted = true
-
-	err = runBuild(cli, options)
-	assert.NilError(t, err)
-
-	files, err := ioutil.ReadDir(dest)
-	assert.NilError(t, err)
-	var actual []string
-	for _, fileInfo := range files {
-		actual = append(actual, fileInfo.Name())
-	}
-	sort.Strings(actual)
-	assert.Check(t, is.DeepEqual([]string{dockerfileName, ".dockerignore", "data"}, actual))
+	assert.Equal(t, []string{dockerfileName, ".dockerignore", "foo"}, actual)
 }
 
 // TestRunBuildFromLocalGitHubDirNonExistingRepo tests that build contexts
 // starting with `github.com/` are special-cased, and the build command attempts
 // to clone the remote repo.
-// TODO: test "context selection" logic directly when runBuild is refactored
-// to support testing (ex: docker/cli#294)
 func TestRunBuildFromGitHubSpecialCase(t *testing.T) {
 	cmd := NewBuildCommand(test.NewFakeCli(nil))
-	// Clone a small repo that exists so git doesn't prompt for credentials
-	cmd.SetArgs([]string{"github.com/docker/for-win"})
+	cmd.SetArgs([]string{"github.com/docker/no-such-repository"})
 	cmd.SetOutput(ioutil.Discard)
 	err := cmd.Execute()
-	assert.ErrorContains(t, err, "unable to prepare context")
-	assert.ErrorContains(t, err, "docker-build-git")
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "unable to prepare context: unable to 'git clone'")
 }
 
 // TestRunBuildFromLocalGitHubDirNonExistingRepo tests that a local directory
@@ -143,57 +125,19 @@ func TestRunBuildFromGitHubSpecialCase(t *testing.T) {
 // case.
 func TestRunBuildFromLocalGitHubDir(t *testing.T) {
 	tmpDir, err := ioutil.TempDir("", "docker-build-from-local-dir-")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	defer os.RemoveAll(tmpDir)
 
 	buildDir := filepath.Join(tmpDir, "github.com", "docker", "no-such-repository")
 	err = os.MkdirAll(buildDir, 0777)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	err = ioutil.WriteFile(filepath.Join(buildDir, "Dockerfile"), []byte("FROM busybox\n"), 0644)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	client := test.NewFakeCli(&fakeClient{})
 	cmd := NewBuildCommand(client)
 	cmd.SetArgs([]string{buildDir})
 	cmd.SetOutput(ioutil.Discard)
 	err = cmd.Execute()
-	assert.NilError(t, err)
-}
-
-func TestRunBuildWithSymlinkedContext(t *testing.T) {
-	dockerfile := `
-FROM alpine:3.6
-RUN echo hello world
-`
-
-	tmpDir := fs.NewDir(t, t.Name(),
-		fs.WithDir("context",
-			fs.WithFile("Dockerfile", dockerfile)),
-		fs.WithSymlink("context-link", "context"))
-	defer tmpDir.Remove()
-
-	files := []string{}
-	fakeImageBuild := func(_ context.Context, context io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
-		tarReader := tar.NewReader(context)
-		for {
-			hdr, err := tarReader.Next()
-			switch err {
-			case io.EOF:
-				body := new(bytes.Buffer)
-				return types.ImageBuildResponse{Body: ioutil.NopCloser(body)}, nil
-			case nil:
-				files = append(files, hdr.Name)
-			default:
-				return types.ImageBuildResponse{}, err
-			}
-		}
-	}
-
-	cli := test.NewFakeCli(&fakeClient{imageBuildFunc: fakeImageBuild})
-	options := newBuildOptions()
-	options.context = tmpDir.Join("context-link")
-	options.untrusted = true
-	assert.NilError(t, runBuild(cli, options))
-
-	assert.DeepEqual(t, files, []string{"Dockerfile"})
+	require.NoError(t, err)
 }

components/cli/cli/command/image/history_test.go

@@ -7,10 +7,11 @@ import (
 	"time"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types/image"
-	"github.com/gotestyourself/gotestyourself/assert"
 	"github.com/gotestyourself/gotestyourself/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNewHistoryCommandErrors(t *testing.T) {
@@ -38,7 +39,7 @@ func TestNewHistoryCommandErrors(t *testing.T) {
 		cmd := NewHistoryCommand(test.NewFakeCli(&fakeClient{imageHistoryFunc: tc.imageHistoryFunc}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -46,6 +47,7 @@ func TestNewHistoryCommandSuccess(t *testing.T) {
 	testCases := []struct {
 		name             string
 		args             []string
+		outputRegex      string
 		imageHistoryFunc func(img string) ([]image.HistoryResponseItem, error)
 	}{
 		{
@@ -62,17 +64,16 @@ func TestNewHistoryCommandSuccess(t *testing.T) {
 			name: "quiet",
 			args: []string{"--quiet", "image:tag"},
 		},
+		// TODO: This test is failing since the output does not contain an RFC3339 date
+		//{
+		//	name:        "non-human",
+		//	args:        []string{"--human=false", "image:tag"},
+		//	outputRegex: "\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}", // RFC3339 date format match
+		//},
 		{
-			name: "non-human",
-			args: []string{"--human=false", "image:tag"},
-			imageHistoryFunc: func(img string) ([]image.HistoryResponseItem, error) {
-				return []image.HistoryResponseItem{{
-					ID:        "abcdef",
-					Created:   time.Date(2017, 1, 1, 12, 0, 3, 0, time.UTC).Unix(),
-					CreatedBy: "rose",
-					Comment:   "new history item!",
-				}}, nil
-			},
+			name:        "non-human-header",
+			args:        []string{"--human=false", "image:tag"},
+			outputRegex: "CREATED\\sAT",
 		},
 		{
 			name: "quiet-no-trunc",
@@ -91,8 +92,12 @@ func TestNewHistoryCommandSuccess(t *testing.T) {
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
 		err := cmd.Execute()
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 		actual := cli.OutBuffer().String()
-		golden.Assert(t, actual, fmt.Sprintf("history-command-success.%s.golden", tc.name))
+		if tc.outputRegex == "" {
+			golden.Assert(t, actual, fmt.Sprintf("history-command-success.%s.golden", tc.name))
+		} else {
+			assert.Regexp(t, tc.outputRegex, actual)
+		}
 	}
 }

components/cli/cli/command/image/import_test.go

@@ -7,10 +7,10 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNewImportCommandErrors(t *testing.T) {
@@ -38,7 +38,7 @@ func TestNewImportCommandErrors(t *testing.T) {
 		cmd := NewImportCommand(test.NewFakeCli(&fakeClient{imageImportFunc: tc.imageImportFunc}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -46,7 +46,7 @@ func TestNewImportCommandInvalidFile(t *testing.T) {
 	cmd := NewImportCommand(test.NewFakeCli(&fakeClient{}))
 	cmd.SetOutput(ioutil.Discard)
 	cmd.SetArgs([]string{"testdata/import-command-success.unexistent-file"})
-	assert.ErrorContains(t, cmd.Execute(), "testdata/import-command-success.unexistent-file")
+	testutil.ErrorContains(t, cmd.Execute(), "testdata/import-command-success.unexistent-file")
 }
 
 func TestNewImportCommandSuccess(t *testing.T) {
@@ -67,7 +67,7 @@ func TestNewImportCommandSuccess(t *testing.T) {
 			name: "double",
 			args: []string{"-", "image:local"},
 			imageImportFunc: func(source types.ImageImportSource, ref string, options types.ImageImportOptions) (io.ReadCloser, error) {
-				assert.Check(t, is.Equal("image:local", ref))
+				assert.Equal(t, "image:local", ref)
 				return ioutil.NopCloser(strings.NewReader("")), nil
 			},
 		},
@@ -75,7 +75,7 @@ func TestNewImportCommandSuccess(t *testing.T) {
 			name: "message",
 			args: []string{"--message", "test message", "-"},
 			imageImportFunc: func(source types.ImageImportSource, ref string, options types.ImageImportOptions) (io.ReadCloser, error) {
-				assert.Check(t, is.Equal("test message", options.Message))
+				assert.Equal(t, "test message", options.Message)
 				return ioutil.NopCloser(strings.NewReader("")), nil
 			},
 		},
@@ -83,7 +83,7 @@ func TestNewImportCommandSuccess(t *testing.T) {
 			name: "change",
 			args: []string{"--change", "ENV DEBUG true", "-"},
 			imageImportFunc: func(source types.ImageImportSource, ref string, options types.ImageImportOptions) (io.ReadCloser, error) {
-				assert.Check(t, is.Equal("ENV DEBUG true", options.Changes[0]))
+				assert.Equal(t, "ENV DEBUG true", options.Changes[0])
 				return ioutil.NopCloser(strings.NewReader("")), nil
 			},
 		},
@@ -92,6 +92,6 @@ func TestNewImportCommandSuccess(t *testing.T) {
 		cmd := NewImportCommand(test.NewFakeCli(&fakeClient{imageImportFunc: tc.imageImportFunc}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 	}
 }

components/cli/cli/command/image/inspect_test.go

@@ -6,10 +6,10 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNewInspectCommandErrors(t *testing.T) {
@@ -28,7 +28,7 @@ func TestNewInspectCommandErrors(t *testing.T) {
 		cmd := newInspectCommand(test.NewFakeCli(&fakeClient{}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -46,7 +46,7 @@ func TestNewInspectCommandSuccess(t *testing.T) {
 			imageCount: 1,
 			imageInspectFunc: func(image string) (types.ImageInspect, []byte, error) {
 				imageInspectInvocationCount++
-				assert.Check(t, is.Equal("image", image))
+				assert.Equal(t, "image", image)
 				return types.ImageInspect{}, nil, nil
 			},
 		},
@@ -66,9 +66,9 @@ func TestNewInspectCommandSuccess(t *testing.T) {
 			imageInspectFunc: func(image string) (types.ImageInspect, []byte, error) {
 				imageInspectInvocationCount++
 				if imageInspectInvocationCount == 1 {
-					assert.Check(t, is.Equal("image1", image))
+					assert.Equal(t, "image1", image)
 				} else {
-					assert.Check(t, is.Equal("image2", image))
+					assert.Equal(t, "image2", image)
 				}
 				return types.ImageInspect{}, nil, nil
 			},
@@ -81,8 +81,8 @@ func TestNewInspectCommandSuccess(t *testing.T) {
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
 		err := cmd.Execute()
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("inspect-command-success.%s.golden", tc.name))
-		assert.Check(t, is.Equal(imageInspectInvocationCount, tc.imageCount))
+		assert.Equal(t, imageInspectInvocationCount, tc.imageCount)
 	}
 }

components/cli/cli/command/image/list_test.go

@@ -7,11 +7,11 @@ import (
 
 	"github.com/docker/cli/cli/config/configfile"
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNewImagesCommandErrors(t *testing.T) {
@@ -38,7 +38,7 @@ func TestNewImagesCommandErrors(t *testing.T) {
 		cmd := NewImagesCommand(test.NewFakeCli(&fakeClient{imageListFunc: tc.imageListFunc}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -65,7 +65,7 @@ func TestNewImagesCommandSuccess(t *testing.T) {
 			name: "match-name",
 			args: []string{"image"},
 			imageListFunc: func(options types.ImageListOptions) ([]types.ImageSummary, error) {
-				assert.Check(t, is.Equal("image", options.Filters.Get("reference")[0]))
+				assert.Equal(t, "image", options.Filters.Get("reference")[0])
 				return []types.ImageSummary{{}}, nil
 			},
 		},
@@ -73,7 +73,7 @@ func TestNewImagesCommandSuccess(t *testing.T) {
 			name: "filters",
 			args: []string{"--filter", "name=value"},
 			imageListFunc: func(options types.ImageListOptions) ([]types.ImageSummary, error) {
-				assert.Check(t, is.Equal("value", options.Filters.Get("name")[0]))
+				assert.Equal(t, "value", options.Filters.Get("name")[0])
 				return []types.ImageSummary{{}}, nil
 			},
 		},
@@ -85,14 +85,14 @@ func TestNewImagesCommandSuccess(t *testing.T) {
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
 		err := cmd.Execute()
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("list-command-success.%s.golden", tc.name))
 	}
 }
 
 func TestNewListCommandAlias(t *testing.T) {
 	cmd := newListCommand(test.NewFakeCli(&fakeClient{}))
-	assert.Check(t, cmd.HasAlias("images"))
-	assert.Check(t, cmd.HasAlias("list"))
-	assert.Check(t, !cmd.HasAlias("other"))
+	assert.True(t, cmd.HasAlias("images"))
+	assert.True(t, cmd.HasAlias("list"))
+	assert.False(t, cmd.HasAlias("other"))
 }

components/cli/cli/command/image/load_test.go

@@ -8,10 +8,11 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
 	"github.com/gotestyourself/gotestyourself/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNewLoadCommandErrors(t *testing.T) {
@@ -46,7 +47,7 @@ func TestNewLoadCommandErrors(t *testing.T) {
 		cmd := NewLoadCommand(cli)
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -56,7 +57,7 @@ func TestNewLoadCommandInvalidInput(t *testing.T) {
 	cmd.SetOutput(ioutil.Discard)
 	cmd.SetArgs([]string{"--input", "*"})
 	err := cmd.Execute()
-	assert.ErrorContains(t, err, expectedError)
+	testutil.ErrorContains(t, err, expectedError)
 }
 
 func TestNewLoadCommandSuccess(t *testing.T) {
@@ -95,7 +96,7 @@ func TestNewLoadCommandSuccess(t *testing.T) {
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
 		err := cmd.Execute()
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("load-command-success.%s.golden", tc.name))
 	}
 }

components/cli/cli/command/image/prune_test.go

@@ -6,12 +6,12 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNewPruneCommandErrors(t *testing.T) {
@@ -41,7 +41,7 @@ func TestNewPruneCommandErrors(t *testing.T) {
 		}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -55,7 +55,7 @@ func TestNewPruneCommandSuccess(t *testing.T) {
 			name: "all",
 			args: []string{"--all"},
 			imagesPruneFunc: func(pruneFilter filters.Args) (types.ImagesPruneReport, error) {
-				assert.Check(t, is.Equal("false", pruneFilter.Get("dangling")[0]))
+				assert.Equal(t, "false", pruneFilter.Get("dangling")[0])
 				return types.ImagesPruneReport{}, nil
 			},
 		},
@@ -63,7 +63,7 @@ func TestNewPruneCommandSuccess(t *testing.T) {
 			name: "force-deleted",
 			args: []string{"--force"},
 			imagesPruneFunc: func(pruneFilter filters.Args) (types.ImagesPruneReport, error) {
-				assert.Check(t, is.Equal("true", pruneFilter.Get("dangling")[0]))
+				assert.Equal(t, "true", pruneFilter.Get("dangling")[0])
 				return types.ImagesPruneReport{
 					ImagesDeleted:  []types.ImageDeleteResponseItem{{Deleted: "image1"}},
 					SpaceReclaimed: 1,
@@ -74,7 +74,7 @@ func TestNewPruneCommandSuccess(t *testing.T) {
 			name: "force-untagged",
 			args: []string{"--force"},
 			imagesPruneFunc: func(pruneFilter filters.Args) (types.ImagesPruneReport, error) {
-				assert.Check(t, is.Equal("true", pruneFilter.Get("dangling")[0]))
+				assert.Equal(t, "true", pruneFilter.Get("dangling")[0])
 				return types.ImagesPruneReport{
 					ImagesDeleted:  []types.ImageDeleteResponseItem{{Untagged: "image1"}},
 					SpaceReclaimed: 2,
@@ -88,7 +88,7 @@ func TestNewPruneCommandSuccess(t *testing.T) {
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
 		err := cmd.Execute()
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("prune-command-success.%s.golden", tc.name))
 	}
 }

components/cli/cli/command/image/pull.go

@@ -14,10 +14,9 @@ import (
 )
 
 type pullOptions struct {
-	remote    string
-	all       bool
-	platform  string
-	untrusted bool
+	remote   string
+	all      bool
+	platform string
 }
 
 // NewPullCommand creates a new `docker pull` command
@@ -39,7 +38,7 @@ func NewPullCommand(dockerCli command.Cli) *cobra.Command {
 	flags.BoolVarP(&opts.all, "all-tags", "a", false, "Download all tagged images in the repository")
 
 	command.AddPlatformFlag(flags, &opts.platform)
-	command.AddTrustVerificationFlags(flags, &opts.untrusted, dockerCli.ContentTrustEnabled())
+	command.AddTrustVerificationFlags(flags)
 
 	return cmd
 }
@@ -59,14 +58,14 @@ func runPull(cli command.Cli, opts pullOptions) error {
 	}
 
 	ctx := context.Background()
-	imgRefAndAuth, err := trust.GetImageReferencesAndAuth(ctx, nil, AuthResolver(cli), distributionRef.String())
+	imgRefAndAuth, err := trust.GetImageReferencesAndAuth(ctx, AuthResolver(cli), distributionRef.String())
 	if err != nil {
 		return err
 	}
 
 	// Check if reference has a digest
 	_, isCanonical := distributionRef.(reference.Canonical)
-	if !opts.untrusted && !isCanonical {
+	if command.IsTrusted() && !isCanonical {
 		err = trustedPull(ctx, cli, imgRefAndAuth, opts.platform)
 	} else {
 		err = imagePullPrivileged(ctx, cli, imgRefAndAuth, opts.all, opts.platform)

components/cli/cli/command/image/pull_test.go

@@ -8,11 +8,10 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
-	"github.com/docker/cli/internal/test/notary"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNewPullCommandErrors(t *testing.T) {
@@ -42,7 +41,7 @@ func TestNewPullCommandErrors(t *testing.T) {
 		cmd := NewPullCommand(cli)
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -66,7 +65,7 @@ func TestNewPullCommandSuccess(t *testing.T) {
 	for _, tc := range testCases {
 		cli := test.NewFakeCli(&fakeClient{
 			imagePullFunc: func(ref string, options types.ImagePullOptions) (io.ReadCloser, error) {
-				assert.Check(t, is.Equal(tc.expectedTag, ref), tc.name)
+				assert.Equal(t, tc.expectedTag, ref, tc.name)
 				return ioutil.NopCloser(strings.NewReader("")), nil
 			},
 		})
@@ -74,48 +73,7 @@ func TestNewPullCommandSuccess(t *testing.T) {
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
 		err := cmd.Execute()
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 		golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("pull-command-success.%s.golden", tc.name))
 	}
 }
-
-func TestNewPullCommandWithContentTrustErrors(t *testing.T) {
-	testCases := []struct {
-		name          string
-		args          []string
-		expectedError string
-		notaryFunc    test.NotaryClientFuncType
-	}{
-		{
-			name:          "offline-notary-server",
-			notaryFunc:    notary.GetOfflineNotaryRepository,
-			expectedError: "client is offline",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "uninitialized-notary-server",
-			notaryFunc:    notary.GetUninitializedNotaryRepository,
-			expectedError: "remote trust data does not exist",
-			args:          []string{"image:tag"},
-		},
-		{
-			name:          "empty-notary-server",
-			notaryFunc:    notary.GetEmptyTargetsNotaryRepository,
-			expectedError: "No valid trust data for tag",
-			args:          []string{"image:tag"},
-		},
-	}
-	for _, tc := range testCases {
-		cli := test.NewFakeCli(&fakeClient{
-			imagePullFunc: func(ref string, options types.ImagePullOptions) (io.ReadCloser, error) {
-				return ioutil.NopCloser(strings.NewReader("")), fmt.Errorf("shouldn't try to pull image")
-			},
-		}, test.EnableContentTrust)
-		cli.SetNotaryClient(tc.notaryFunc)
-		cmd := NewPullCommand(cli)
-		cmd.SetOutput(ioutil.Discard)
-		cmd.SetArgs(tc.args)
-		err := cmd.Execute()
-		assert.ErrorContains(t, err, tc.expectedError)
-	}
-}

components/cli/cli/command/image/push.go

@@ -11,34 +11,26 @@ import (
 	"github.com/spf13/cobra"
 )
 
-type pushOptions struct {
-	remote    string
-	untrusted bool
-}
-
 // NewPushCommand creates a new `docker push` command
 func NewPushCommand(dockerCli command.Cli) *cobra.Command {
-	var opts pushOptions
-
 	cmd := &cobra.Command{
 		Use:   "push [OPTIONS] NAME[:TAG]",
 		Short: "Push an image or a repository to a registry",
 		Args:  cli.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.remote = args[0]
-			return runPush(dockerCli, opts)
+			return runPush(dockerCli, args[0])
 		},
 	}
 
 	flags := cmd.Flags()
 
-	command.AddTrustSigningFlags(flags, &opts.untrusted, dockerCli.ContentTrustEnabled())
+	command.AddTrustSigningFlags(flags)
 
 	return cmd
 }
 
-func runPush(dockerCli command.Cli, opts pushOptions) error {
-	ref, err := reference.ParseNormalizedNamed(opts.remote)
+func runPush(dockerCli command.Cli, remote string) error {
+	ref, err := reference.ParseNormalizedNamed(remote)
 	if err != nil {
 		return err
 	}
@@ -55,7 +47,7 @@ func runPush(dockerCli command.Cli, opts pushOptions) error {
 	authConfig := command.ResolveAuthConfig(ctx, dockerCli, repoInfo.Index)
 	requestPrivilege := command.RegistryAuthenticationPrivilegedFunc(dockerCli, repoInfo.Index, "push")
 
-	if !opts.untrusted {
+	if command.IsTrusted() {
 		return TrustedPush(ctx, dockerCli, repoInfo, ref, authConfig, requestPrivilege)
 	}
 

components/cli/cli/command/image/push_test.go

@@ -7,9 +7,10 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNewPushCommandErrors(t *testing.T) {
@@ -37,13 +38,18 @@ func TestNewPushCommandErrors(t *testing.T) {
 				return ioutil.NopCloser(strings.NewReader("")), errors.Errorf("Failed to push")
 			},
 		},
+		{
+			name:          "trust-error",
+			args:          []string{"--disable-content-trust=false", "image:repo"},
+			expectedError: "you are not authorized to perform this operation: server returned 401.",
+		},
 	}
 	for _, tc := range testCases {
 		cli := test.NewFakeCli(&fakeClient{imagePushFunc: tc.imagePushFunc})
 		cmd := NewPushCommand(cli)
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -66,6 +72,6 @@ func TestNewPushCommandSuccess(t *testing.T) {
 		cmd := NewPushCommand(cli)
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 	}
 }

components/cli/cli/command/image/remove.go

@@ -81,7 +81,7 @@ func runRemove(dockerCli command.Cli, opts removeOptions, images []string) error
 		if !opts.force || fatalErr {
 			return errors.New(msg)
 		}
-		fmt.Fprintln(dockerCli.Err(), msg)
+		fmt.Fprintf(dockerCli.Err(), msg)
 	}
 	return nil
 }

components/cli/cli/command/image/remove_test.go

@@ -6,11 +6,11 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/docker/docker/api/types"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
 	"github.com/gotestyourself/gotestyourself/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 type notFound struct {
@@ -27,9 +27,9 @@ func (n notFound) NotFound() bool {
 
 func TestNewRemoveCommandAlias(t *testing.T) {
 	cmd := newRemoveCommand(test.NewFakeCli(&fakeClient{}))
-	assert.Check(t, cmd.HasAlias("rmi"))
-	assert.Check(t, cmd.HasAlias("remove"))
-	assert.Check(t, !cmd.HasAlias("other"))
+	assert.True(t, cmd.HasAlias("rmi"))
+	assert.True(t, cmd.HasAlias("remove"))
+	assert.False(t, cmd.HasAlias("other"))
 }
 
 func TestNewRemoveCommandErrors(t *testing.T) {
@@ -48,7 +48,7 @@ func TestNewRemoveCommandErrors(t *testing.T) {
 			args:          []string{"-f", "image1"},
 			expectedError: "error removing image",
 			imageRemoveFunc: func(image string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
-				assert.Check(t, is.Equal("image1", image))
+				assert.Equal(t, "image1", image)
 				return []types.ImageDeleteResponseItem{}, errors.Errorf("error removing image")
 			},
 		},
@@ -57,8 +57,8 @@ func TestNewRemoveCommandErrors(t *testing.T) {
 			args:          []string{"arg1"},
 			expectedError: "error removing image",
 			imageRemoveFunc: func(image string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
-				assert.Check(t, !options.Force)
-				assert.Check(t, options.PruneChildren)
+				assert.False(t, options.Force)
+				assert.True(t, options.PruneChildren)
 				return []types.ImageDeleteResponseItem{}, errors.Errorf("error removing image")
 			},
 		},
@@ -70,7 +70,7 @@ func TestNewRemoveCommandErrors(t *testing.T) {
 			}))
 			cmd.SetOutput(ioutil.Discard)
 			cmd.SetArgs(tc.args)
-			assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+			testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 		})
 	}
 }
@@ -86,7 +86,7 @@ func TestNewRemoveCommandSuccess(t *testing.T) {
 			name: "Image Deleted",
 			args: []string{"image1"},
 			imageRemoveFunc: func(image string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
-				assert.Check(t, is.Equal("image1", image))
+				assert.Equal(t, "image1", image)
 				return []types.ImageDeleteResponseItem{{Deleted: image}}, nil
 			},
 		},
@@ -94,18 +94,18 @@ func TestNewRemoveCommandSuccess(t *testing.T) {
 			name: "Image not found with force option",
 			args: []string{"-f", "image1"},
 			imageRemoveFunc: func(image string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
-				assert.Check(t, is.Equal("image1", image))
-				assert.Check(t, is.Equal(true, options.Force))
+				assert.Equal(t, "image1", image)
+				assert.Equal(t, true, options.Force)
 				return []types.ImageDeleteResponseItem{}, notFound{"image1"}
 			},
-			expectedStderr: "Error: No such image: image1\n",
+			expectedStderr: "Error: No such image: image1",
 		},
 
 		{
 			name: "Image Untagged",
 			args: []string{"image1"},
 			imageRemoveFunc: func(image string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
-				assert.Check(t, is.Equal("image1", image))
+				assert.Equal(t, "image1", image)
 				return []types.ImageDeleteResponseItem{{Untagged: image}}, nil
 			},
 		},
@@ -126,8 +126,8 @@ func TestNewRemoveCommandSuccess(t *testing.T) {
 			cmd := NewRemoveCommand(cli)
 			cmd.SetOutput(ioutil.Discard)
 			cmd.SetArgs(tc.args)
-			assert.NilError(t, cmd.Execute())
-			assert.Check(t, is.Equal(tc.expectedStderr, cli.ErrBuffer().String()))
+			assert.NoError(t, cmd.Execute())
+			assert.Equal(t, tc.expectedStderr, cli.ErrBuffer().String())
 			golden.Assert(t, cli.OutBuffer().String(), fmt.Sprintf("remove-command-success.%s.golden", tc.name))
 		})
 	}

components/cli/cli/command/image/save_test.go

@@ -8,9 +8,10 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/docker/cli/internal/test/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewSaveCommandErrors(t *testing.T) {
@@ -53,7 +54,7 @@ func TestNewSaveCommandErrors(t *testing.T) {
 		cmd := NewSaveCommand(cli)
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -68,8 +69,8 @@ func TestNewSaveCommandSuccess(t *testing.T) {
 			args:       []string{"-o", "save_tmp_file", "arg1"},
 			isTerminal: true,
 			imageSaveFunc: func(images []string) (io.ReadCloser, error) {
-				assert.Assert(t, is.Len(images, 1))
-				assert.Check(t, is.Equal("arg1", images[0]))
+				require.Len(t, images, 1)
+				assert.Equal(t, "arg1", images[0])
 				return ioutil.NopCloser(strings.NewReader("")), nil
 			},
 			deferredFunc: func() {
@@ -80,9 +81,9 @@ func TestNewSaveCommandSuccess(t *testing.T) {
 			args:       []string{"arg1", "arg2"},
 			isTerminal: false,
 			imageSaveFunc: func(images []string) (io.ReadCloser, error) {
-				assert.Assert(t, is.Len(images, 2))
-				assert.Check(t, is.Equal("arg1", images[0]))
-				assert.Check(t, is.Equal("arg2", images[1]))
+				require.Len(t, images, 2)
+				assert.Equal(t, "arg1", images[0])
+				assert.Equal(t, "arg2", images[1])
 				return ioutil.NopCloser(strings.NewReader("")), nil
 			},
 		},
@@ -95,7 +96,7 @@ func TestNewSaveCommandSuccess(t *testing.T) {
 		}))
 		cmd.SetOutput(ioutil.Discard)
 		cmd.SetArgs(tc.args)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		if tc.deferredFunc != nil {
 			tc.deferredFunc()
 		}

components/cli/cli/command/image/tag_test.go

@@ -5,8 +5,8 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/docker/cli/internal/test/testutil"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCliNewTagCommandErrors(t *testing.T) {
@@ -20,7 +20,7 @@ func TestCliNewTagCommandErrors(t *testing.T) {
 		cmd := NewTagCommand(test.NewFakeCli(&fakeClient{}))
 		cmd.SetArgs(args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), expectedError)
 	}
 }
 
@@ -28,14 +28,14 @@ func TestCliNewTagCommand(t *testing.T) {
 	cmd := NewTagCommand(
 		test.NewFakeCli(&fakeClient{
 			imageTagFunc: func(image string, ref string) error {
-				assert.Check(t, is.Equal("image1", image))
-				assert.Check(t, is.Equal("image2", ref))
+				assert.Equal(t, "image1", image)
+				assert.Equal(t, "image2", ref)
 				return nil
 			},
 		}))
 	cmd.SetArgs([]string{"image1", "image2"})
 	cmd.SetOutput(ioutil.Discard)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	value, _ := cmd.Flags().GetBool("interspersed")
-	assert.Check(t, !value)
+	assert.False(t, value)
 }

components/cli/cli/command/image/testdata/history-command-success.non-human.golden

@@ -1,2 +0,0 @@
-IMAGE               CREATED AT             CREATED BY          SIZE                COMMENT
-abcdef              2017-01-01T12:00:03Z   rose                0                   new history item!

components/cli/cli/command/image/trust.go

@@ -198,7 +198,7 @@ func trustedPull(ctx context.Context, cli command.Cli, imgRefAndAuth trust.Image
 		if err != nil {
 			return err
 		}
-		updatedImgRefAndAuth, err := trust.GetImageReferencesAndAuth(ctx, nil, AuthResolver(cli), trustedRef.String())
+		updatedImgRefAndAuth, err := trust.GetImageReferencesAndAuth(ctx, AuthResolver(cli), trustedRef.String())
 		if err != nil {
 			return err
 		}
@@ -293,24 +293,35 @@ func imagePullPrivileged(ctx context.Context, cli command.Cli, imgRefAndAuth tru
 
 // TrustedReference returns the canonical trusted reference for an image reference
 func TrustedReference(ctx context.Context, cli command.Cli, ref reference.NamedTagged, rs registry.Service) (reference.Canonical, error) {
-	imgRefAndAuth, err := trust.GetImageReferencesAndAuth(ctx, rs, AuthResolver(cli), ref.String())
+	var (
+		repoInfo *registry.RepositoryInfo
+		err      error
+	)
+	if rs != nil {
+		repoInfo, err = rs.ResolveRepository(ref)
+	} else {
+		repoInfo, err = registry.ParseRepositoryInfo(ref)
+	}
 	if err != nil {
 		return nil, err
 	}
 
-	notaryRepo, err := cli.NotaryClient(imgRefAndAuth, []string{"pull"})
+	// Resolve the Auth config relevant for this server
+	authConfig := command.ResolveAuthConfig(ctx, cli, repoInfo.Index)
+
+	notaryRepo, err := trust.GetNotaryRepository(cli.In(), cli.Out(), command.UserAgent(), repoInfo, &authConfig, "pull")
 	if err != nil {
 		return nil, errors.Wrap(err, "error establishing connection to trust repository")
 	}
 
 	t, err := notaryRepo.GetTargetByName(ref.Tag(), trust.ReleasesRole, data.CanonicalTargetsRole)
 	if err != nil {
-		return nil, trust.NotaryError(imgRefAndAuth.RepoInfo().Name.Name(), err)
+		return nil, trust.NotaryError(repoInfo.Name.Name(), err)
 	}
 	// Only list tags in the top level targets role or the releases delegation role - ignore
 	// all other delegation roles
 	if t.Role != trust.ReleasesRole && t.Role != data.CanonicalTargetsRole {
-		return nil, trust.NotaryError(imgRefAndAuth.RepoInfo().Name.Name(), client.ErrNoSuchTarget(ref.Tag()))
+		return nil, trust.NotaryError(repoInfo.Name.Name(), client.ErrNoSuchTarget(ref.Tag()))
 	}
 	r, err := convertTarget(t.Target)
 	if err != nil {

components/cli/cli/command/image/trust_test.go

@@ -8,7 +8,8 @@ import (
 	"github.com/docker/cli/cli/trust"
 	registrytypes "github.com/docker/docker/api/types/registry"
 	"github.com/docker/docker/registry"
-	"github.com/gotestyourself/gotestyourself/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/theupdateframework/notary/client"
 	"github.com/theupdateframework/notary/passphrase"
 	"github.com/theupdateframework/notary/trustpinning"
@@ -63,12 +64,12 @@ func TestNonOfficialTrustServer(t *testing.T) {
 
 func TestAddTargetToAllSignableRolesError(t *testing.T) {
 	tmpDir, err := ioutil.TempDir("", "notary-test-")
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 	defer os.RemoveAll(tmpDir)
 
 	notaryRepo, err := client.NewFileCachedRepository(tmpDir, "gun", "https://localhost", nil, passphrase.ConstantRetriever("password"), trustpinning.TrustPinConfig{})
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	target := client.Target{}
 	err = AddTargetToAllSignableRoles(notaryRepo, &target)
-	assert.Error(t, err, "client is offline")
+	assert.EqualError(t, err, "client is offline")
 }

components/cli/cli/command/inspect/inspector_test.go

@@ -6,8 +6,8 @@ import (
 	"testing"
 
 	"github.com/docker/cli/templates"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type testElement struct {
@@ -243,17 +243,17 @@ func TestTemplateInspectorRawFallbackNumber(t *testing.T) {
 	}
 	b := new(bytes.Buffer)
 	tmpl, err := templates.Parse("{{.Size}} {{.Id}}")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	i := NewTemplateInspector(b, tmpl)
 	for _, tc := range testcases {
 		err = i.Inspect(typedElem, tc.raw)
-		assert.NilError(t, err)
+		require.NoError(t, err)
 
 		err = i.Flush()
-		assert.NilError(t, err)
+		require.NoError(t, err)
 
-		assert.Check(t, is.Equal(tc.exp, b.String()))
+		assert.Equal(t, tc.exp, b.String())
 		b.Reset()
 	}
 }

components/cli/cli/command/manifest/annotate.go

@@ -1,93 +0,0 @@
-package manifest
-
-import (
-	"fmt"
-
-	"github.com/docker/cli/cli"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/manifest/store"
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-)
-
-type annotateOptions struct {
-	target     string // the target manifest list name (also transaction ID)
-	image      string // the manifest to annotate within the list
-	variant    string // an architecture variant
-	os         string
-	arch       string
-	osFeatures []string
-}
-
-// NewAnnotateCommand creates a new `docker manifest annotate` command
-func newAnnotateCommand(dockerCli command.Cli) *cobra.Command {
-	var opts annotateOptions
-
-	cmd := &cobra.Command{
-		Use:   "annotate [OPTIONS] MANIFEST_LIST MANIFEST",
-		Short: "Add additional information to a local image manifest",
-		Args:  cli.ExactArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts.target = args[0]
-			opts.image = args[1]
-			return runManifestAnnotate(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-
-	flags.StringVar(&opts.os, "os", "", "Set operating system")
-	flags.StringVar(&opts.arch, "arch", "", "Set architecture")
-	flags.StringSliceVar(&opts.osFeatures, "os-features", []string{}, "Set operating system feature")
-	flags.StringVar(&opts.variant, "variant", "", "Set architecture variant")
-
-	return cmd
-}
-
-func runManifestAnnotate(dockerCli command.Cli, opts annotateOptions) error {
-	targetRef, err := normalizeReference(opts.target)
-	if err != nil {
-		return errors.Wrapf(err, "annotate: error parsing name for manifest list %s", opts.target)
-	}
-	imgRef, err := normalizeReference(opts.image)
-	if err != nil {
-		return errors.Wrapf(err, "annotate: error parsing name for manifest %s", opts.image)
-	}
-
-	manifestStore := dockerCli.ManifestStore()
-	imageManifest, err := manifestStore.Get(targetRef, imgRef)
-	switch {
-	case store.IsNotFound(err):
-		return fmt.Errorf("manifest for image %s does not exist in %s", opts.image, opts.target)
-	case err != nil:
-		return err
-	}
-
-	// Update the mf
-	if opts.os != "" {
-		imageManifest.Platform.OS = opts.os
-	}
-	if opts.arch != "" {
-		imageManifest.Platform.Architecture = opts.arch
-	}
-	for _, osFeature := range opts.osFeatures {
-		imageManifest.Platform.OSFeatures = appendIfUnique(imageManifest.Platform.OSFeatures, osFeature)
-	}
-	if opts.variant != "" {
-		imageManifest.Platform.Variant = opts.variant
-	}
-
-	if !isValidOSArch(imageManifest.Platform.OS, imageManifest.Platform.Architecture) {
-		return errors.Errorf("manifest entry for image has unsupported os/arch combination: %s/%s", opts.os, opts.arch)
-	}
-	return manifestStore.Save(targetRef, imgRef, imageManifest)
-}
-
-func appendIfUnique(list []string, str string) []string {
-	for _, s := range list {
-		if s == str {
-			return list
-		}
-	}
-	return append(list, str)
-}

components/cli/cli/command/manifest/annotate_test.go

@@ -1,77 +0,0 @@
-package manifest
-
-import (
-	"io/ioutil"
-	"testing"
-
-	"github.com/docker/cli/internal/test"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/golden"
-)
-
-func TestManifestAnnotateError(t *testing.T) {
-	testCases := []struct {
-		args          []string
-		expectedError string
-	}{
-		{
-			args:          []string{"too-few-arguments"},
-			expectedError: "requires exactly 2 arguments",
-		},
-		{
-			args:          []string{"th!si'sa/fa!ke/li$t/name", "example.com/alpine:3.0"},
-			expectedError: "error parsing name for manifest list",
-		},
-		{
-			args:          []string{"example.com/list:v1", "th!si'sa/fa!ke/im@ge/nam32"},
-			expectedError: "error parsing name for manifest",
-		},
-	}
-
-	for _, tc := range testCases {
-		cli := test.NewFakeCli(nil)
-		cmd := newAnnotateCommand(cli)
-		cmd.SetArgs(tc.args)
-		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
-	}
-}
-
-func TestManifestAnnotate(t *testing.T) {
-	store, cleanup := newTempManifestStore(t)
-	defer cleanup()
-
-	cli := test.NewFakeCli(nil)
-	cli.SetManifestStore(store)
-	namedRef := ref(t, "alpine:3.0")
-	imageManifest := fullImageManifest(t, namedRef)
-	err := store.Save(ref(t, "list:v1"), namedRef, imageManifest)
-	assert.NilError(t, err)
-
-	cmd := newAnnotateCommand(cli)
-	cmd.SetArgs([]string{"example.com/list:v1", "example.com/fake:0.0"})
-	cmd.SetOutput(ioutil.Discard)
-	expectedError := "manifest for image example.com/fake:0.0 does not exist"
-	assert.ErrorContains(t, cmd.Execute(), expectedError)
-
-	cmd.SetArgs([]string{"example.com/list:v1", "example.com/alpine:3.0"})
-	cmd.Flags().Set("os", "freebsd")
-	cmd.Flags().Set("arch", "fake")
-	cmd.Flags().Set("os-features", "feature1")
-	cmd.Flags().Set("variant", "v7")
-	expectedError = "manifest entry for image has unsupported os/arch combination"
-	assert.ErrorContains(t, cmd.Execute(), expectedError)
-
-	cmd.Flags().Set("arch", "arm")
-	assert.NilError(t, cmd.Execute())
-
-	cmd = newInspectCommand(cli)
-	err = cmd.Flags().Set("verbose", "true")
-	assert.NilError(t, err)
-	cmd.SetArgs([]string{"example.com/list:v1", "example.com/alpine:3.0"})
-	assert.NilError(t, cmd.Execute())
-	actual := cli.OutBuffer()
-	expected := golden.Get(t, "inspect-annotate.golden")
-	assert.Check(t, is.Equal(string(expected), actual.String()))
-}

components/cli/cli/command/manifest/client_test.go

@@ -1,46 +0,0 @@
-package manifest
-
-import (
-	manifesttypes "github.com/docker/cli/cli/manifest/types"
-	"github.com/docker/cli/cli/registry/client"
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/reference"
-	"github.com/opencontainers/go-digest"
-	"golang.org/x/net/context"
-)
-
-type fakeRegistryClient struct {
-	client.RegistryClient
-	getManifestFunc     func(ctx context.Context, ref reference.Named) (manifesttypes.ImageManifest, error)
-	getManifestListFunc func(ctx context.Context, ref reference.Named) ([]manifesttypes.ImageManifest, error)
-	mountBlobFunc       func(ctx context.Context, source reference.Canonical, target reference.Named) error
-	putManifestFunc     func(ctx context.Context, source reference.Named, mf distribution.Manifest) (digest.Digest, error)
-}
-
-func (c *fakeRegistryClient) GetManifest(ctx context.Context, ref reference.Named) (manifesttypes.ImageManifest, error) {
-	if c.getManifestFunc != nil {
-		return c.getManifestFunc(ctx, ref)
-	}
-	return manifesttypes.ImageManifest{}, nil
-}
-
-func (c *fakeRegistryClient) GetManifestList(ctx context.Context, ref reference.Named) ([]manifesttypes.ImageManifest, error) {
-	if c.getManifestListFunc != nil {
-		return c.getManifestListFunc(ctx, ref)
-	}
-	return nil, nil
-}
-
-func (c *fakeRegistryClient) MountBlob(ctx context.Context, source reference.Canonical, target reference.Named) error {
-	if c.mountBlobFunc != nil {
-		return c.mountBlobFunc(ctx, source, target)
-	}
-	return nil
-}
-
-func (c *fakeRegistryClient) PutManifest(ctx context.Context, ref reference.Named, mf distribution.Manifest) (digest.Digest, error) {
-	if c.putManifestFunc != nil {
-		return c.putManifestFunc(ctx, ref, mf)
-	}
-	return digest.Digest(""), nil
-}

components/cli/cli/command/manifest/cmd.go

@@ -1,45 +0,0 @@
-package manifest
-
-import (
-	"fmt"
-
-	"github.com/docker/cli/cli"
-	"github.com/docker/cli/cli/command"
-
-	"github.com/spf13/cobra"
-)
-
-// NewManifestCommand returns a cobra command for `manifest` subcommands
-func NewManifestCommand(dockerCli command.Cli) *cobra.Command {
-	// use dockerCli as command.Cli
-	cmd := &cobra.Command{
-		Use:   "manifest COMMAND",
-		Short: "Manage Docker image manifests and manifest lists",
-		Long:  manifestDescription,
-		Args:  cli.NoArgs,
-		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Fprintf(dockerCli.Err(), "\n"+cmd.UsageString())
-		},
-		Annotations: map[string]string{"experimentalCLI": ""},
-	}
-	cmd.AddCommand(
-		newCreateListCommand(dockerCli),
-		newInspectCommand(dockerCli),
-		newAnnotateCommand(dockerCli),
-		newPushListCommand(dockerCli),
-	)
-	return cmd
-}
-
-var manifestDescription = `
-The **docker manifest** command has subcommands for managing image manifests and
-manifest lists. A manifest list allows you to use one name to refer to the same image
-built for multiple architectures.
-
-To see help for a subcommand, use:
-
-    docker manifest CMD --help
-
-For full details on using docker manifest lists, see the registry v2 specification.
-
-`

components/cli/cli/command/manifest/create_list.go

@@ -1,82 +0,0 @@
-package manifest
-
-import (
-	"fmt"
-
-	"github.com/docker/cli/cli"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/manifest/store"
-	"github.com/docker/docker/registry"
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-	"golang.org/x/net/context"
-)
-
-type createOpts struct {
-	amend    bool
-	insecure bool
-}
-
-func newCreateListCommand(dockerCli command.Cli) *cobra.Command {
-	opts := createOpts{}
-
-	cmd := &cobra.Command{
-		Use:   "create MANIFEST_LIST MANIFEST [MANIFEST...]",
-		Short: "Create a local manifest list for annotating and pushing to a registry",
-		Args:  cli.RequiresMinArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return createManifestList(dockerCli, args, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVar(&opts.insecure, "insecure", false, "allow communication with an insecure registry")
-	flags.BoolVarP(&opts.amend, "amend", "a", false, "Amend an existing manifest list")
-	return cmd
-}
-
-func createManifestList(dockerCli command.Cli, args []string, opts createOpts) error {
-	newRef := args[0]
-	targetRef, err := normalizeReference(newRef)
-	if err != nil {
-		return errors.Wrapf(err, "error parsing name for manifest list %s", newRef)
-	}
-
-	_, err = registry.ParseRepositoryInfo(targetRef)
-	if err != nil {
-		return errors.Wrapf(err, "error parsing repository name for manifest list %s", newRef)
-	}
-
-	manifestStore := dockerCli.ManifestStore()
-	_, err = manifestStore.GetList(targetRef)
-	switch {
-	case store.IsNotFound(err):
-		// New manifest list
-	case err != nil:
-		return err
-	case !opts.amend:
-		return errors.Errorf("refusing to amend an existing manifest list with no --amend flag")
-	}
-
-	ctx := context.Background()
-	// Now create the local manifest list transaction by looking up the manifest schemas
-	// for the constituent images:
-	manifests := args[1:]
-	for _, manifestRef := range manifests {
-		namedRef, err := normalizeReference(manifestRef)
-		if err != nil {
-			// TODO: wrap error?
-			return err
-		}
-
-		manifest, err := getManifest(ctx, dockerCli, targetRef, namedRef, opts.insecure)
-		if err != nil {
-			return err
-		}
-		if err := manifestStore.Save(targetRef, namedRef, manifest); err != nil {
-			return err
-		}
-	}
-	fmt.Fprintf(dockerCli.Out(), "Created manifest list %s\n", targetRef.String())
-	return nil
-}

components/cli/cli/command/manifest/create_test.go

@@ -1,116 +0,0 @@
-package manifest
-
-import (
-	"io/ioutil"
-	"testing"
-
-	manifesttypes "github.com/docker/cli/cli/manifest/types"
-	"github.com/docker/cli/internal/test"
-	"github.com/docker/distribution/reference"
-	"github.com/gotestyourself/gotestyourself/assert"
-	is "github.com/gotestyourself/gotestyourself/assert/cmp"
-	"github.com/gotestyourself/gotestyourself/golden"
-	"github.com/pkg/errors"
-	"golang.org/x/net/context"
-)
-
-func TestManifestCreateErrors(t *testing.T) {
-	testCases := []struct {
-		args          []string
-		expectedError string
-	}{
-		{
-			args:          []string{"too-few-arguments"},
-			expectedError: "requires at least 2 arguments",
-		},
-		{
-			args:          []string{"th!si'sa/fa!ke/li$t/name", "example.com/alpine:3.0"},
-			expectedError: "error parsing name for manifest list",
-		},
-	}
-
-	for _, tc := range testCases {
-		cli := test.NewFakeCli(nil)
-		cmd := newCreateListCommand(cli)
-		cmd.SetArgs(tc.args)
-		cmd.SetOutput(ioutil.Discard)
-		assert.ErrorContains(t, cmd.Execute(), tc.expectedError)
-	}
-}
-
-// create a manifest list, then overwrite it, and inspect to see if the old one is still there
-func TestManifestCreateAmend(t *testing.T) {
-	store, cleanup := newTempManifestStore(t)
-	defer cleanup()
-
-	cli := test.NewFakeCli(nil)
-	cli.SetManifestStore(store)
-
-	namedRef := ref(t, "alpine:3.0")
-	imageManifest := fullImageManifest(t, namedRef)
-	err := store.Save(ref(t, "list:v1"), namedRef, imageManifest)
-	assert.NilError(t, err)
-	namedRef = ref(t, "alpine:3.1")
-	imageManifest = fullImageManifest(t, namedRef)
-	err = store.Save(ref(t, "list:v1"), namedRef, imageManifest)
-	assert.NilError(t, err)
-
-	cmd := newCreateListCommand(cli)
-	cmd.SetArgs([]string{"example.com/list:v1", "example.com/alpine:3.1"})
-	cmd.Flags().Set("amend", "true")
-	cmd.SetOutput(ioutil.Discard)
-	err = cmd.Execute()
-	assert.NilError(t, err)
-
-	// make a new cli to clear the buffers
-	cli = test.NewFakeCli(nil)
-	cli.SetManifestStore(store)
-	inspectCmd := newInspectCommand(cli)
-	inspectCmd.SetArgs([]string{"example.com/list:v1"})
-	assert.NilError(t, inspectCmd.Execute())
-	actual := cli.OutBuffer()
-	expected := golden.Get(t, "inspect-manifest-list.golden")
-	assert.Check(t, is.Equal(string(expected), actual.String()))
-}
-
-// attempt to overwrite a saved manifest and get refused
-func TestManifestCreateRefuseAmend(t *testing.T) {
-	store, cleanup := newTempManifestStore(t)
-	defer cleanup()
-
-	cli := test.NewFakeCli(nil)
-	cli.SetManifestStore(store)
-	namedRef := ref(t, "alpine:3.0")
-	imageManifest := fullImageManifest(t, namedRef)
-	err := store.Save(ref(t, "list:v1"), namedRef, imageManifest)
-	assert.NilError(t, err)
-
-	cmd := newCreateListCommand(cli)
-	cmd.SetArgs([]string{"example.com/list:v1", "example.com/alpine:3.0"})
-	cmd.SetOutput(ioutil.Discard)
-	err = cmd.Execute()
-	assert.Error(t, err, "refusing to amend an existing manifest list with no --amend flag")
-}
-
-// attempt to make a manifest list without valid images
-func TestManifestCreateNoManifest(t *testing.T) {
-	store, cleanup := newTempManifestStore(t)
-	defer cleanup()
-
-	cli := test.NewFakeCli(nil)
-	cli.SetManifestStore(store)
-	cli.SetRegistryClient(&fakeRegistryClient{
-		getManifestFunc: func(_ context.Context, ref reference.Named) (manifesttypes.ImageManifest, error) {
-			return manifesttypes.ImageManifest{}, errors.Errorf("No such image: %v", ref)
-		},
-		getManifestListFunc: func(ctx context.Context, ref reference.Named) ([]manifesttypes.ImageManifest, error) {
-			return nil, errors.Errorf("No such manifest: %s", ref)
-		},
-	})
-
-	cmd := newCreateListCommand(cli)
-	cmd.SetArgs([]string{"example.com/list:v1", "example.com/alpine:3.0"})
-	cmd.SetOutput(ioutil.Discard)
-	err := cmd.Execute()
-	assert.Error(t, err, "No such image: example.com/alpine:3.0")
-}

components/cli/cli/command/manifest/inspect.go

@@ -1,147 +0,0 @@
-package manifest
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-
-	"github.com/docker/cli/cli"
-	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/manifest/types"
-	"github.com/docker/distribution/manifest/manifestlist"
-	"github.com/docker/distribution/reference"
-	"github.com/docker/docker/registry"
-	"github.com/spf13/cobra"
-	"golang.org/x/net/context"
-)
-
-type inspectOptions struct {
-	ref      string
-	list     string
-	verbose  bool
-	insecure bool
-}
-
-// NewInspectCommand creates a new `docker manifest inspect` command
-func newInspectCommand(dockerCli command.Cli) *cobra.Command {
-	var opts inspectOptions
-
-	cmd := &cobra.Command{
-		Use:   "inspect [OPTIONS] [MANIFEST_LIST] MANIFEST",
-		Short: "Display an image manifest, or manifest list",
-		Args:  cli.RequiresRangeArgs(1, 2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			switch len(args) {
-			case 1:
-				opts.ref = args[0]
-			case 2:
-				opts.list = args[0]
-				opts.ref = args[1]
-			}
-			return runInspect(dockerCli, opts)
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.BoolVar(&opts.insecure, "insecure", false, "allow communication with an insecure registry")
-	flags.BoolVarP(&opts.verbose, "verbose", "v", false, "Output additional info including layers and platform")
-	return cmd
-}
-
-func runInspect(dockerCli command.Cli, opts inspectOptions) error {
-	namedRef, err := normalizeReference(opts.ref)
-	if err != nil {
-		return err
-	}
-
-	// If list reference is provided, display the local manifest in a list
-	if opts.list != "" {
-		listRef, err := normalizeReference(opts.list)
-		if err != nil {
-			return err
-		}
-
-		imageManifest, err := dockerCli.ManifestStore().Get(listRef, namedRef)
-		if err != nil {
-			return err
-		}
-		return printManifest(dockerCli, imageManifest, opts)
-	}
-
-	// Try a local manifest list first
-	localManifestList, err := dockerCli.ManifestStore().GetList(namedRef)
-	if err == nil {
-		return printManifestList(dockerCli, namedRef, localManifestList, opts)
-	}
-
-	// Next try a remote manifest
-	ctx := context.Background()
-	registryClient := dockerCli.RegistryClient(opts.insecure)
-	imageManifest, err := registryClient.GetManifest(ctx, namedRef)
-	if err == nil {
-		return printManifest(dockerCli, imageManifest, opts)
-	}
-
-	// Finally try a remote manifest list
-	manifestList, err := registryClient.GetManifestList(ctx, namedRef)
-	if err != nil {
-		return err
-	}
-	return printManifestList(dockerCli, namedRef, manifestList, opts)
-}
-
-func printManifest(dockerCli command.Cli, manifest types.ImageManifest, opts inspectOptions) error {
-	buffer := new(bytes.Buffer)
-	if !opts.verbose {
-		_, raw, err := manifest.Payload()
-		if err != nil {
-			return err
-		}
-		if err := json.Indent(buffer, raw, "", "\t"); err != nil {
-			return err
-		}
-		fmt.Fprintln(dockerCli.Out(), buffer.String())
-		return nil
-	}
-	jsonBytes, err := json.MarshalIndent(manifest, "", "\t")
-	if err != nil {
-		return err
-	}
-	dockerCli.Out().Write(append(jsonBytes, '\n'))
-	return nil
-}
-
-func printManifestList(dockerCli command.Cli, namedRef reference.Named, list []types.ImageManifest, opts inspectOptions) error {
-	if !opts.verbose {
-		targetRepo, err := registry.ParseRepositoryInfo(namedRef)
-		if err != nil {
-			return err
-		}
-
-		manifests := []manifestlist.ManifestDescriptor{}
-		// More than one response. This is a manifest list.
-		for _, img := range list {
-			mfd, err := buildManifestDescriptor(targetRepo, img)
-			if err != nil {
-				return fmt.Errorf("error assembling ManifestDescriptor")
-			}
-			manifests = append(manifests, mfd)
-		}
-		deserializedML, err := manifestlist.FromDescriptors(manifests)
-		if err != nil {
-			return err
-		}
-		jsonBytes, err := deserializedML.MarshalJSON()
-		if err != nil {
-			return err
-		}
-		fmt.Fprintln(dockerCli.Out(), string(jsonBytes))
-		return nil
-	}
-	jsonBytes, err := json.MarshalIndent(list, "", "\t")
-	if err != nil {
-		return err
-	}
-	dockerCli.Out().Write(append(jsonBytes, '\n'))
-	return nil
-}