Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

docker

package

Go to main page

Versions in this module

v1

v1.14.0

Nov 4, 2025

Changes in this version

+ const DefaultRegistryPort

+ const HostPortParts

+ const RegistryContainerPort

+ const RegistryDataPath

+ const RegistryHostIP

+ const RegistryImageName

+ const RegistryLabelKey

+ const RegistryPortBase

+ const RegistryRestartPolicy

+ var ErrRegistryAlreadyExists = errors.New("registry already exists")

+ var ErrRegistryNotFound = errors.New("registry not found")

+ var ErrRegistryPortNotFound = errors.New("registry port not found")

+ func NormalizeVolumeName(registryName string) string

+ type RegistryConfig struct

+ ClusterName string

+ Name string

+ NetworkName string

+ Port int

+ UpstreamURL string

+ VolumeName string

+ type RegistryManager struct

+ func NewRegistryManager(apiClient client.APIClient) (*RegistryManager, error)

+ func (rm *RegistryManager) CreateRegistry(ctx context.Context, config RegistryConfig) error

+ func (rm *RegistryManager) DeleteRegistry(ctx context.Context, name, _ string, deleteVolume bool, networkName string) error

+ func (rm *RegistryManager) GetRegistryPort(ctx context.Context, name string) (int, error)

+ func (rm *RegistryManager) IsRegistryInUse(ctx context.Context, name string) (bool, error)

+ func (rm *RegistryManager) ListRegistries(ctx context.Context) ([]string, error)

v1.13.3

Oct 29, 2025

v1.13.2

Oct 28, 2025

v1.13.1

Oct 23, 2025

v1.13.0

Oct 20, 2025

v1.12.5

Oct 19, 2025

v1.12.4

Oct 19, 2025

v1.12.3

Oct 19, 2025

v1.12.2

Oct 14, 2025

Changes in this version

+ var ErrAPIClientNil = errors.New("apiClient cannot be nil")

+ var ErrClientNotReady = errors.New("client not ready")

+ var ErrEngineDetection = errors.New("unable to detect engine type from client")

+ var ErrNoContainerEngine = errors.New("no container engine (Docker or Podman) available")

+ func GetDockerClient() (client.APIClient, error)

+ func GetPodmanSystemClient() (client.APIClient, error)

+ func GetPodmanUserClient() (client.APIClient, error)

+ type ClientCreator func() (client.APIClient, error)

+ type ContainerEngine struct

+ Client client.APIClient

+ func GetAutoDetectedClient(creators ...ClientCreator) (*ContainerEngine, error)

+ func NewContainerEngine(apiClient client.APIClient) (*ContainerEngine, error)

+ func (u *ContainerEngine) CheckReady(ctx context.Context) (bool, error)

+ func (u *ContainerEngine) GetName() string

+ type MockAPIClient struct

+ func NewMockAPIClient(t interface{ ... }) *MockAPIClient

+ func (_m *MockAPIClient) EXPECT() *MockAPIClient_Expecter

+ func (_mock *MockAPIClient) BuildCachePrune(ctx context.Context, opts build.CachePruneOptions) (*build.CachePruneReport, error)

+ func (_mock *MockAPIClient) BuildCancel(ctx context.Context, id string) error

+ func (_mock *MockAPIClient) CheckpointCreate(ctx context.Context, container string, options checkpoint.CreateOptions) error

+ func (_mock *MockAPIClient) CheckpointDelete(ctx context.Context, container string, options checkpoint.DeleteOptions) error

+ func (_mock *MockAPIClient) CheckpointList(ctx context.Context, container string, options checkpoint.ListOptions) ([]checkpoint.Summary, error)

+ func (_mock *MockAPIClient) ClientVersion() string

+ func (_mock *MockAPIClient) Close() error

+ func (_mock *MockAPIClient) ConfigCreate(ctx context.Context, config swarm.ConfigSpec) (swarm.ConfigCreateResponse, error)

+ func (_mock *MockAPIClient) ConfigInspectWithRaw(ctx context.Context, name string) (swarm.Config, []byte, error)

+ func (_mock *MockAPIClient) ConfigList(ctx context.Context, options swarm.ConfigListOptions) ([]swarm.Config, error)

+ func (_mock *MockAPIClient) ConfigRemove(ctx context.Context, id string) error

+ func (_mock *MockAPIClient) ConfigUpdate(ctx context.Context, id string, version swarm.Version, config swarm.ConfigSpec) error

+ func (_mock *MockAPIClient) ContainerAttach(ctx context.Context, container1 string, options container.AttachOptions) (types.HijackedResponse, error)

+ func (_mock *MockAPIClient) ContainerCommit(ctx context.Context, container1 string, options container.CommitOptions) (container.CommitResponse, error)

+ func (_mock *MockAPIClient) ContainerCreate(ctx context.Context, config *container.Config, ...) (container.CreateResponse, error)

+ func (_mock *MockAPIClient) ContainerDiff(ctx context.Context, container1 string) ([]container.FilesystemChange, error)

+ func (_mock *MockAPIClient) ContainerExecAttach(ctx context.Context, execID string, options container.ExecAttachOptions) (types.HijackedResponse, error)

+ func (_mock *MockAPIClient) ContainerExecCreate(ctx context.Context, container1 string, options container.ExecOptions) (container.ExecCreateResponse, error)

+ func (_mock *MockAPIClient) ContainerExecInspect(ctx context.Context, execID string) (container.ExecInspect, error)

+ func (_mock *MockAPIClient) ContainerExecResize(ctx context.Context, execID string, options container.ResizeOptions) error

+ func (_mock *MockAPIClient) ContainerExecStart(ctx context.Context, execID string, options container.ExecStartOptions) error

+ func (_mock *MockAPIClient) ContainerExport(ctx context.Context, container1 string) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) ContainerInspect(ctx context.Context, container1 string) (container.InspectResponse, error)

+ func (_mock *MockAPIClient) ContainerInspectWithRaw(ctx context.Context, container1 string, getSize bool) (container.InspectResponse, []byte, error)

+ func (_mock *MockAPIClient) ContainerKill(ctx context.Context, container1 string, signal string) error

+ func (_mock *MockAPIClient) ContainerList(ctx context.Context, options container.ListOptions) ([]container.Summary, error)

+ func (_mock *MockAPIClient) ContainerLogs(ctx context.Context, container1 string, options container.LogsOptions) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) ContainerPause(ctx context.Context, container1 string) error

+ func (_mock *MockAPIClient) ContainerRemove(ctx context.Context, container1 string, options container.RemoveOptions) error

+ func (_mock *MockAPIClient) ContainerRename(ctx context.Context, container1 string, newContainerName string) error

+ func (_mock *MockAPIClient) ContainerResize(ctx context.Context, container1 string, options container.ResizeOptions) error

+ func (_mock *MockAPIClient) ContainerRestart(ctx context.Context, container1 string, options container.StopOptions) error

+ func (_mock *MockAPIClient) ContainerStart(ctx context.Context, container1 string, options container.StartOptions) error

+ func (_mock *MockAPIClient) ContainerStatPath(ctx context.Context, container1 string, path string) (container.PathStat, error)

+ func (_mock *MockAPIClient) ContainerStats(ctx context.Context, container1 string, stream bool) (container.StatsResponseReader, error)

+ func (_mock *MockAPIClient) ContainerStatsOneShot(ctx context.Context, container1 string) (container.StatsResponseReader, error)

+ func (_mock *MockAPIClient) ContainerStop(ctx context.Context, container1 string, options container.StopOptions) error

+ func (_mock *MockAPIClient) ContainerTop(ctx context.Context, container1 string, arguments []string) (container.TopResponse, error)

+ func (_mock *MockAPIClient) ContainerUnpause(ctx context.Context, container1 string) error

+ func (_mock *MockAPIClient) ContainerUpdate(ctx context.Context, container1 string, updateConfig container.UpdateConfig) (container.UpdateResponse, error)

+ func (_mock *MockAPIClient) ContainerWait(ctx context.Context, container1 string, condition container.WaitCondition) (<-chan container.WaitResponse, <-chan error)

+ func (_mock *MockAPIClient) ContainersPrune(ctx context.Context, pruneFilters filters.Args) (container.PruneReport, error)

+ func (_mock *MockAPIClient) CopyFromContainer(ctx context.Context, container1 string, srcPath string) (io.ReadCloser, container.PathStat, error)

+ func (_mock *MockAPIClient) CopyToContainer(ctx context.Context, container1 string, path string, content io.Reader, ...) error

+ func (_mock *MockAPIClient) DaemonHost() string

+ func (_mock *MockAPIClient) DialHijack(ctx context.Context, url string, proto string, meta map[string][]string) (net.Conn, error)

+ func (_mock *MockAPIClient) Dialer() func(context.Context) (net.Conn, error)

+ func (_mock *MockAPIClient) DiskUsage(ctx context.Context, options types.DiskUsageOptions) (types.DiskUsage, error)

+ func (_mock *MockAPIClient) DistributionInspect(ctx context.Context, image string, encodedRegistryAuth string) (registry.DistributionInspect, error)

+ func (_mock *MockAPIClient) Events(ctx context.Context, options events.ListOptions) (<-chan events.Message, <-chan error)

+ func (_mock *MockAPIClient) HTTPClient() *http.Client

+ func (_mock *MockAPIClient) ImageBuild(ctx context.Context, context1 io.Reader, options build.ImageBuildOptions) (build.ImageBuildResponse, error)

+ func (_mock *MockAPIClient) ImageCreate(ctx context.Context, parentReference string, options image.CreateOptions) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) ImageHistory(ctx context.Context, image1 string, ...) ([]image.HistoryResponseItem, error)

+ func (_mock *MockAPIClient) ImageImport(ctx context.Context, source image.ImportSource, ref string, ...) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) ImageInspect(ctx context.Context, image1 string, ...) (image.InspectResponse, error)

+ func (_mock *MockAPIClient) ImageInspectWithRaw(ctx context.Context, image1 string) (image.InspectResponse, []byte, error)

+ func (_mock *MockAPIClient) ImageList(ctx context.Context, options image.ListOptions) ([]image.Summary, error)

+ func (_mock *MockAPIClient) ImageLoad(ctx context.Context, input io.Reader, ...) (image.LoadResponse, error)

+ func (_mock *MockAPIClient) ImagePull(ctx context.Context, ref string, options image.PullOptions) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) ImagePush(ctx context.Context, ref string, options image.PushOptions) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) ImageRemove(ctx context.Context, image1 string, options image.RemoveOptions) ([]image.DeleteResponse, error)

+ func (_mock *MockAPIClient) ImageSave(ctx context.Context, images []string, ...) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) ImageSearch(ctx context.Context, term string, options registry.SearchOptions) ([]registry.SearchResult, error)

+ func (_mock *MockAPIClient) ImageTag(ctx context.Context, image1 string, ref string) error

+ func (_mock *MockAPIClient) ImagesPrune(ctx context.Context, pruneFilter filters.Args) (image.PruneReport, error)

+ func (_mock *MockAPIClient) Info(ctx context.Context) (system.Info, error)

+ func (_mock *MockAPIClient) NegotiateAPIVersion(ctx context.Context)

+ func (_mock *MockAPIClient) NegotiateAPIVersionPing(ping types.Ping)

+ func (_mock *MockAPIClient) NetworkConnect(ctx context.Context, network1 string, container1 string, ...) error

+ func (_mock *MockAPIClient) NetworkCreate(ctx context.Context, name string, options network.CreateOptions) (network.CreateResponse, error)

+ func (_mock *MockAPIClient) NetworkDisconnect(ctx context.Context, network1 string, container1 string, force bool) error

+ func (_mock *MockAPIClient) NetworkInspect(ctx context.Context, network1 string, options network.InspectOptions) (network.Inspect, error)

+ func (_mock *MockAPIClient) NetworkInspectWithRaw(ctx context.Context, network1 string, options network.InspectOptions) (network.Inspect, []byte, error)

+ func (_mock *MockAPIClient) NetworkList(ctx context.Context, options network.ListOptions) ([]network.Summary, error)

+ func (_mock *MockAPIClient) NetworkRemove(ctx context.Context, network1 string) error

+ func (_mock *MockAPIClient) NetworksPrune(ctx context.Context, pruneFilter filters.Args) (network.PruneReport, error)

+ func (_mock *MockAPIClient) NodeInspectWithRaw(ctx context.Context, nodeID string) (swarm.Node, []byte, error)

+ func (_mock *MockAPIClient) NodeList(ctx context.Context, options swarm.NodeListOptions) ([]swarm.Node, error)

+ func (_mock *MockAPIClient) NodeRemove(ctx context.Context, nodeID string, options swarm.NodeRemoveOptions) error

+ func (_mock *MockAPIClient) NodeUpdate(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec) error

+ func (_mock *MockAPIClient) Ping(ctx context.Context) (types.Ping, error)

+ func (_mock *MockAPIClient) PluginCreate(ctx context.Context, createContext io.Reader, ...) error

+ func (_mock *MockAPIClient) PluginDisable(ctx context.Context, name string, options types.PluginDisableOptions) error

+ func (_mock *MockAPIClient) PluginEnable(ctx context.Context, name string, options types.PluginEnableOptions) error

+ func (_mock *MockAPIClient) PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error)

+ func (_mock *MockAPIClient) PluginInstall(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) PluginList(ctx context.Context, filter filters.Args) (types.PluginsListResponse, error)

+ func (_mock *MockAPIClient) PluginPush(ctx context.Context, name string, registryAuth string) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) PluginRemove(ctx context.Context, name string, options types.PluginRemoveOptions) error

+ func (_mock *MockAPIClient) PluginSet(ctx context.Context, name string, args []string) error

+ func (_mock *MockAPIClient) PluginUpgrade(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) RegistryLogin(ctx context.Context, auth registry.AuthConfig) (registry.AuthenticateOKBody, error)

+ func (_mock *MockAPIClient) SecretCreate(ctx context.Context, secret swarm.SecretSpec) (swarm.SecretCreateResponse, error)

+ func (_mock *MockAPIClient) SecretInspectWithRaw(ctx context.Context, name string) (swarm.Secret, []byte, error)

+ func (_mock *MockAPIClient) SecretList(ctx context.Context, options swarm.SecretListOptions) ([]swarm.Secret, error)

+ func (_mock *MockAPIClient) SecretRemove(ctx context.Context, id string) error

+ func (_mock *MockAPIClient) SecretUpdate(ctx context.Context, id string, version swarm.Version, secret swarm.SecretSpec) error

+ func (_mock *MockAPIClient) ServerVersion(ctx context.Context) (types.Version, error)

+ func (_mock *MockAPIClient) ServiceCreate(ctx context.Context, service swarm.ServiceSpec, ...) (swarm.ServiceCreateResponse, error)

+ func (_mock *MockAPIClient) ServiceInspectWithRaw(ctx context.Context, serviceID string, options swarm.ServiceInspectOptions) (swarm.Service, []byte, error)

+ func (_mock *MockAPIClient) ServiceList(ctx context.Context, options swarm.ServiceListOptions) ([]swarm.Service, error)

+ func (_mock *MockAPIClient) ServiceLogs(ctx context.Context, serviceID string, options container.LogsOptions) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) ServiceRemove(ctx context.Context, serviceID string) error

+ func (_mock *MockAPIClient) ServiceUpdate(ctx context.Context, serviceID string, version swarm.Version, ...) (swarm.ServiceUpdateResponse, error)

+ func (_mock *MockAPIClient) SwarmGetUnlockKey(ctx context.Context) (swarm.UnlockKeyResponse, error)

+ func (_mock *MockAPIClient) SwarmInit(ctx context.Context, req swarm.InitRequest) (string, error)

+ func (_mock *MockAPIClient) SwarmInspect(ctx context.Context) (swarm.Swarm, error)

+ func (_mock *MockAPIClient) SwarmJoin(ctx context.Context, req swarm.JoinRequest) error

+ func (_mock *MockAPIClient) SwarmLeave(ctx context.Context, force bool) error

+ func (_mock *MockAPIClient) SwarmUnlock(ctx context.Context, req swarm.UnlockRequest) error

+ func (_mock *MockAPIClient) SwarmUpdate(ctx context.Context, version swarm.Version, swarm1 swarm.Spec, ...) error

+ func (_mock *MockAPIClient) TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error)

+ func (_mock *MockAPIClient) TaskList(ctx context.Context, options swarm.TaskListOptions) ([]swarm.Task, error)

+ func (_mock *MockAPIClient) TaskLogs(ctx context.Context, taskID string, options container.LogsOptions) (io.ReadCloser, error)

+ func (_mock *MockAPIClient) VolumeCreate(ctx context.Context, options volume.CreateOptions) (volume.Volume, error)

+ func (_mock *MockAPIClient) VolumeInspect(ctx context.Context, volumeID string) (volume.Volume, error)

+ func (_mock *MockAPIClient) VolumeInspectWithRaw(ctx context.Context, volumeID string) (volume.Volume, []byte, error)

+ func (_mock *MockAPIClient) VolumeList(ctx context.Context, options volume.ListOptions) (volume.ListResponse, error)

+ func (_mock *MockAPIClient) VolumeRemove(ctx context.Context, volumeID string, force bool) error

+ func (_mock *MockAPIClient) VolumeUpdate(ctx context.Context, volumeID string, version swarm.Version, ...) error

+ func (_mock *MockAPIClient) VolumesPrune(ctx context.Context, pruneFilter filters.Args) (volume.PruneReport, error)

+ type MockAPIClient_BuildCachePrune_Call struct

+ func (_c *MockAPIClient_BuildCachePrune_Call) Return(cachePruneReport *build.CachePruneReport, err error) *MockAPIClient_BuildCachePrune_Call

+ func (_c *MockAPIClient_BuildCachePrune_Call) Run(run func(ctx context.Context, opts build.CachePruneOptions)) *MockAPIClient_BuildCachePrune_Call

+ func (_c *MockAPIClient_BuildCachePrune_Call) RunAndReturn(...) *MockAPIClient_BuildCachePrune_Call

+ type MockAPIClient_BuildCancel_Call struct

+ func (_c *MockAPIClient_BuildCancel_Call) Return(err error) *MockAPIClient_BuildCancel_Call

+ func (_c *MockAPIClient_BuildCancel_Call) Run(run func(ctx context.Context, id string)) *MockAPIClient_BuildCancel_Call

+ func (_c *MockAPIClient_BuildCancel_Call) RunAndReturn(run func(ctx context.Context, id string) error) *MockAPIClient_BuildCancel_Call

+ type MockAPIClient_CheckpointCreate_Call struct

+ func (_c *MockAPIClient_CheckpointCreate_Call) Return(err error) *MockAPIClient_CheckpointCreate_Call

+ func (_c *MockAPIClient_CheckpointCreate_Call) Run(...) *MockAPIClient_CheckpointCreate_Call

+ func (_c *MockAPIClient_CheckpointCreate_Call) RunAndReturn(...) *MockAPIClient_CheckpointCreate_Call

+ type MockAPIClient_CheckpointDelete_Call struct

+ func (_c *MockAPIClient_CheckpointDelete_Call) Return(err error) *MockAPIClient_CheckpointDelete_Call

+ func (_c *MockAPIClient_CheckpointDelete_Call) Run(...) *MockAPIClient_CheckpointDelete_Call

+ func (_c *MockAPIClient_CheckpointDelete_Call) RunAndReturn(...) *MockAPIClient_CheckpointDelete_Call

+ type MockAPIClient_CheckpointList_Call struct

+ func (_c *MockAPIClient_CheckpointList_Call) Return(summarys []checkpoint.Summary, err error) *MockAPIClient_CheckpointList_Call

+ func (_c *MockAPIClient_CheckpointList_Call) Run(...) *MockAPIClient_CheckpointList_Call

+ func (_c *MockAPIClient_CheckpointList_Call) RunAndReturn(...) *MockAPIClient_CheckpointList_Call

+ type MockAPIClient_ClientVersion_Call struct

+ func (_c *MockAPIClient_ClientVersion_Call) Return(s string) *MockAPIClient_ClientVersion_Call

+ func (_c *MockAPIClient_ClientVersion_Call) Run(run func()) *MockAPIClient_ClientVersion_Call

+ func (_c *MockAPIClient_ClientVersion_Call) RunAndReturn(run func() string) *MockAPIClient_ClientVersion_Call

+ type MockAPIClient_Close_Call struct

+ func (_c *MockAPIClient_Close_Call) Return(err error) *MockAPIClient_Close_Call

+ func (_c *MockAPIClient_Close_Call) Run(run func()) *MockAPIClient_Close_Call

+ func (_c *MockAPIClient_Close_Call) RunAndReturn(run func() error) *MockAPIClient_Close_Call

+ type MockAPIClient_ConfigCreate_Call struct

+ func (_c *MockAPIClient_ConfigCreate_Call) Return(configCreateResponse swarm.ConfigCreateResponse, err error) *MockAPIClient_ConfigCreate_Call

+ func (_c *MockAPIClient_ConfigCreate_Call) Run(run func(ctx context.Context, config swarm.ConfigSpec)) *MockAPIClient_ConfigCreate_Call

+ func (_c *MockAPIClient_ConfigCreate_Call) RunAndReturn(...) *MockAPIClient_ConfigCreate_Call

+ type MockAPIClient_ConfigInspectWithRaw_Call struct

+ func (_c *MockAPIClient_ConfigInspectWithRaw_Call) Return(config swarm.Config, bytes []byte, err error) *MockAPIClient_ConfigInspectWithRaw_Call

+ func (_c *MockAPIClient_ConfigInspectWithRaw_Call) Run(run func(ctx context.Context, name string)) *MockAPIClient_ConfigInspectWithRaw_Call

+ func (_c *MockAPIClient_ConfigInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, name string) (swarm.Config, []byte, error)) *MockAPIClient_ConfigInspectWithRaw_Call

+ type MockAPIClient_ConfigList_Call struct

+ func (_c *MockAPIClient_ConfigList_Call) Return(configs []swarm.Config, err error) *MockAPIClient_ConfigList_Call

+ func (_c *MockAPIClient_ConfigList_Call) Run(run func(ctx context.Context, options swarm.ConfigListOptions)) *MockAPIClient_ConfigList_Call

+ func (_c *MockAPIClient_ConfigList_Call) RunAndReturn(...) *MockAPIClient_ConfigList_Call

+ type MockAPIClient_ConfigRemove_Call struct

+ func (_c *MockAPIClient_ConfigRemove_Call) Return(err error) *MockAPIClient_ConfigRemove_Call

+ func (_c *MockAPIClient_ConfigRemove_Call) Run(run func(ctx context.Context, id string)) *MockAPIClient_ConfigRemove_Call

+ func (_c *MockAPIClient_ConfigRemove_Call) RunAndReturn(run func(ctx context.Context, id string) error) *MockAPIClient_ConfigRemove_Call

+ type MockAPIClient_ConfigUpdate_Call struct

+ func (_c *MockAPIClient_ConfigUpdate_Call) Return(err error) *MockAPIClient_ConfigUpdate_Call

+ func (_c *MockAPIClient_ConfigUpdate_Call) Run(...) *MockAPIClient_ConfigUpdate_Call

+ func (_c *MockAPIClient_ConfigUpdate_Call) RunAndReturn(...) *MockAPIClient_ConfigUpdate_Call

+ type MockAPIClient_ContainerAttach_Call struct

+ func (_c *MockAPIClient_ContainerAttach_Call) Return(hijackedResponse types.HijackedResponse, err error) *MockAPIClient_ContainerAttach_Call

+ func (_c *MockAPIClient_ContainerAttach_Call) Run(...) *MockAPIClient_ContainerAttach_Call

+ func (_c *MockAPIClient_ContainerAttach_Call) RunAndReturn(...) *MockAPIClient_ContainerAttach_Call

+ type MockAPIClient_ContainerCommit_Call struct

+ func (_c *MockAPIClient_ContainerCommit_Call) Return(v container.CommitResponse, err error) *MockAPIClient_ContainerCommit_Call

+ func (_c *MockAPIClient_ContainerCommit_Call) Run(...) *MockAPIClient_ContainerCommit_Call

+ func (_c *MockAPIClient_ContainerCommit_Call) RunAndReturn(...) *MockAPIClient_ContainerCommit_Call

+ type MockAPIClient_ContainerCreate_Call struct

+ func (_c *MockAPIClient_ContainerCreate_Call) Return(createResponse container.CreateResponse, err error) *MockAPIClient_ContainerCreate_Call

+ func (_c *MockAPIClient_ContainerCreate_Call) Run(run func(ctx context.Context, config *container.Config, ...)) *MockAPIClient_ContainerCreate_Call

+ func (_c *MockAPIClient_ContainerCreate_Call) RunAndReturn(...) *MockAPIClient_ContainerCreate_Call

+ type MockAPIClient_ContainerDiff_Call struct

+ func (_c *MockAPIClient_ContainerDiff_Call) Return(filesystemChanges []container.FilesystemChange, err error) *MockAPIClient_ContainerDiff_Call

+ func (_c *MockAPIClient_ContainerDiff_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerDiff_Call

+ func (_c *MockAPIClient_ContainerDiff_Call) RunAndReturn(...) *MockAPIClient_ContainerDiff_Call

+ type MockAPIClient_ContainerExecAttach_Call struct

+ func (_c *MockAPIClient_ContainerExecAttach_Call) Return(hijackedResponse types.HijackedResponse, err error) *MockAPIClient_ContainerExecAttach_Call

+ func (_c *MockAPIClient_ContainerExecAttach_Call) Run(...) *MockAPIClient_ContainerExecAttach_Call

+ func (_c *MockAPIClient_ContainerExecAttach_Call) RunAndReturn(...) *MockAPIClient_ContainerExecAttach_Call

+ type MockAPIClient_ContainerExecCreate_Call struct

+ func (_c *MockAPIClient_ContainerExecCreate_Call) Return(v container.ExecCreateResponse, err error) *MockAPIClient_ContainerExecCreate_Call

+ func (_c *MockAPIClient_ContainerExecCreate_Call) Run(...) *MockAPIClient_ContainerExecCreate_Call

+ func (_c *MockAPIClient_ContainerExecCreate_Call) RunAndReturn(...) *MockAPIClient_ContainerExecCreate_Call

+ type MockAPIClient_ContainerExecInspect_Call struct

+ func (_c *MockAPIClient_ContainerExecInspect_Call) Return(execInspect container.ExecInspect, err error) *MockAPIClient_ContainerExecInspect_Call

+ func (_c *MockAPIClient_ContainerExecInspect_Call) Run(run func(ctx context.Context, execID string)) *MockAPIClient_ContainerExecInspect_Call

+ func (_c *MockAPIClient_ContainerExecInspect_Call) RunAndReturn(run func(ctx context.Context, execID string) (container.ExecInspect, error)) *MockAPIClient_ContainerExecInspect_Call

+ type MockAPIClient_ContainerExecResize_Call struct

+ func (_c *MockAPIClient_ContainerExecResize_Call) Return(err error) *MockAPIClient_ContainerExecResize_Call

+ func (_c *MockAPIClient_ContainerExecResize_Call) Run(run func(ctx context.Context, execID string, options container.ResizeOptions)) *MockAPIClient_ContainerExecResize_Call

+ func (_c *MockAPIClient_ContainerExecResize_Call) RunAndReturn(...) *MockAPIClient_ContainerExecResize_Call

+ type MockAPIClient_ContainerExecStart_Call struct

+ func (_c *MockAPIClient_ContainerExecStart_Call) Return(err error) *MockAPIClient_ContainerExecStart_Call

+ func (_c *MockAPIClient_ContainerExecStart_Call) Run(...) *MockAPIClient_ContainerExecStart_Call

+ func (_c *MockAPIClient_ContainerExecStart_Call) RunAndReturn(...) *MockAPIClient_ContainerExecStart_Call

+ type MockAPIClient_ContainerExport_Call struct

+ func (_c *MockAPIClient_ContainerExport_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ContainerExport_Call

+ func (_c *MockAPIClient_ContainerExport_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerExport_Call

+ func (_c *MockAPIClient_ContainerExport_Call) RunAndReturn(run func(ctx context.Context, container1 string) (io.ReadCloser, error)) *MockAPIClient_ContainerExport_Call

+ type MockAPIClient_ContainerInspectWithRaw_Call struct

+ func (_c *MockAPIClient_ContainerInspectWithRaw_Call) Return(inspectResponse container.InspectResponse, bytes []byte, err error) *MockAPIClient_ContainerInspectWithRaw_Call

+ func (_c *MockAPIClient_ContainerInspectWithRaw_Call) Run(run func(ctx context.Context, container1 string, getSize bool)) *MockAPIClient_ContainerInspectWithRaw_Call

+ func (_c *MockAPIClient_ContainerInspectWithRaw_Call) RunAndReturn(...) *MockAPIClient_ContainerInspectWithRaw_Call

+ type MockAPIClient_ContainerInspect_Call struct

+ func (_c *MockAPIClient_ContainerInspect_Call) Return(inspectResponse container.InspectResponse, err error) *MockAPIClient_ContainerInspect_Call

+ func (_c *MockAPIClient_ContainerInspect_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerInspect_Call

+ func (_c *MockAPIClient_ContainerInspect_Call) RunAndReturn(...) *MockAPIClient_ContainerInspect_Call

+ type MockAPIClient_ContainerKill_Call struct

+ func (_c *MockAPIClient_ContainerKill_Call) Return(err error) *MockAPIClient_ContainerKill_Call

+ func (_c *MockAPIClient_ContainerKill_Call) Run(run func(ctx context.Context, container1 string, signal string)) *MockAPIClient_ContainerKill_Call

+ func (_c *MockAPIClient_ContainerKill_Call) RunAndReturn(run func(ctx context.Context, container1 string, signal string) error) *MockAPIClient_ContainerKill_Call

+ type MockAPIClient_ContainerList_Call struct

+ func (_c *MockAPIClient_ContainerList_Call) Return(summarys []container.Summary, err error) *MockAPIClient_ContainerList_Call

+ func (_c *MockAPIClient_ContainerList_Call) Run(run func(ctx context.Context, options container.ListOptions)) *MockAPIClient_ContainerList_Call

+ func (_c *MockAPIClient_ContainerList_Call) RunAndReturn(...) *MockAPIClient_ContainerList_Call

+ type MockAPIClient_ContainerLogs_Call struct

+ func (_c *MockAPIClient_ContainerLogs_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ContainerLogs_Call

+ func (_c *MockAPIClient_ContainerLogs_Call) Run(...) *MockAPIClient_ContainerLogs_Call

+ func (_c *MockAPIClient_ContainerLogs_Call) RunAndReturn(...) *MockAPIClient_ContainerLogs_Call

+ type MockAPIClient_ContainerPause_Call struct

+ func (_c *MockAPIClient_ContainerPause_Call) Return(err error) *MockAPIClient_ContainerPause_Call

+ func (_c *MockAPIClient_ContainerPause_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerPause_Call

+ func (_c *MockAPIClient_ContainerPause_Call) RunAndReturn(run func(ctx context.Context, container1 string) error) *MockAPIClient_ContainerPause_Call

+ type MockAPIClient_ContainerRemove_Call struct

+ func (_c *MockAPIClient_ContainerRemove_Call) Return(err error) *MockAPIClient_ContainerRemove_Call

+ func (_c *MockAPIClient_ContainerRemove_Call) Run(...) *MockAPIClient_ContainerRemove_Call

+ func (_c *MockAPIClient_ContainerRemove_Call) RunAndReturn(...) *MockAPIClient_ContainerRemove_Call

+ type MockAPIClient_ContainerRename_Call struct

+ func (_c *MockAPIClient_ContainerRename_Call) Return(err error) *MockAPIClient_ContainerRename_Call

+ func (_c *MockAPIClient_ContainerRename_Call) Run(run func(ctx context.Context, container1 string, newContainerName string)) *MockAPIClient_ContainerRename_Call

+ func (_c *MockAPIClient_ContainerRename_Call) RunAndReturn(...) *MockAPIClient_ContainerRename_Call

+ type MockAPIClient_ContainerResize_Call struct

+ func (_c *MockAPIClient_ContainerResize_Call) Return(err error) *MockAPIClient_ContainerResize_Call

+ func (_c *MockAPIClient_ContainerResize_Call) Run(...) *MockAPIClient_ContainerResize_Call

+ func (_c *MockAPIClient_ContainerResize_Call) RunAndReturn(...) *MockAPIClient_ContainerResize_Call

+ type MockAPIClient_ContainerRestart_Call struct

+ func (_c *MockAPIClient_ContainerRestart_Call) Return(err error) *MockAPIClient_ContainerRestart_Call

+ func (_c *MockAPIClient_ContainerRestart_Call) Run(...) *MockAPIClient_ContainerRestart_Call

+ func (_c *MockAPIClient_ContainerRestart_Call) RunAndReturn(...) *MockAPIClient_ContainerRestart_Call

+ type MockAPIClient_ContainerStart_Call struct

+ func (_c *MockAPIClient_ContainerStart_Call) Return(err error) *MockAPIClient_ContainerStart_Call

+ func (_c *MockAPIClient_ContainerStart_Call) Run(...) *MockAPIClient_ContainerStart_Call

+ func (_c *MockAPIClient_ContainerStart_Call) RunAndReturn(...) *MockAPIClient_ContainerStart_Call

+ type MockAPIClient_ContainerStatPath_Call struct

+ func (_c *MockAPIClient_ContainerStatPath_Call) Return(pathStat container.PathStat, err error) *MockAPIClient_ContainerStatPath_Call

+ func (_c *MockAPIClient_ContainerStatPath_Call) Run(run func(ctx context.Context, container1 string, path string)) *MockAPIClient_ContainerStatPath_Call

+ func (_c *MockAPIClient_ContainerStatPath_Call) RunAndReturn(...) *MockAPIClient_ContainerStatPath_Call

+ type MockAPIClient_ContainerStatsOneShot_Call struct

+ func (_c *MockAPIClient_ContainerStatsOneShot_Call) Return(statsResponseReader container.StatsResponseReader, err error) *MockAPIClient_ContainerStatsOneShot_Call

+ func (_c *MockAPIClient_ContainerStatsOneShot_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerStatsOneShot_Call

+ func (_c *MockAPIClient_ContainerStatsOneShot_Call) RunAndReturn(...) *MockAPIClient_ContainerStatsOneShot_Call

+ type MockAPIClient_ContainerStats_Call struct

+ func (_c *MockAPIClient_ContainerStats_Call) Return(statsResponseReader container.StatsResponseReader, err error) *MockAPIClient_ContainerStats_Call

+ func (_c *MockAPIClient_ContainerStats_Call) Run(run func(ctx context.Context, container1 string, stream bool)) *MockAPIClient_ContainerStats_Call

+ func (_c *MockAPIClient_ContainerStats_Call) RunAndReturn(...) *MockAPIClient_ContainerStats_Call

+ type MockAPIClient_ContainerStop_Call struct

+ func (_c *MockAPIClient_ContainerStop_Call) Return(err error) *MockAPIClient_ContainerStop_Call

+ func (_c *MockAPIClient_ContainerStop_Call) Run(...) *MockAPIClient_ContainerStop_Call

+ func (_c *MockAPIClient_ContainerStop_Call) RunAndReturn(...) *MockAPIClient_ContainerStop_Call

+ type MockAPIClient_ContainerTop_Call struct

+ func (_c *MockAPIClient_ContainerTop_Call) Return(topResponse container.TopResponse, err error) *MockAPIClient_ContainerTop_Call

+ func (_c *MockAPIClient_ContainerTop_Call) Run(run func(ctx context.Context, container1 string, arguments []string)) *MockAPIClient_ContainerTop_Call

+ func (_c *MockAPIClient_ContainerTop_Call) RunAndReturn(...) *MockAPIClient_ContainerTop_Call

+ type MockAPIClient_ContainerUnpause_Call struct

+ func (_c *MockAPIClient_ContainerUnpause_Call) Return(err error) *MockAPIClient_ContainerUnpause_Call

+ func (_c *MockAPIClient_ContainerUnpause_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerUnpause_Call

+ func (_c *MockAPIClient_ContainerUnpause_Call) RunAndReturn(run func(ctx context.Context, container1 string) error) *MockAPIClient_ContainerUnpause_Call

+ type MockAPIClient_ContainerUpdate_Call struct

+ func (_c *MockAPIClient_ContainerUpdate_Call) Return(updateResponse container.UpdateResponse, err error) *MockAPIClient_ContainerUpdate_Call

+ func (_c *MockAPIClient_ContainerUpdate_Call) Run(...) *MockAPIClient_ContainerUpdate_Call

+ func (_c *MockAPIClient_ContainerUpdate_Call) RunAndReturn(...) *MockAPIClient_ContainerUpdate_Call

+ type MockAPIClient_ContainerWait_Call struct

+ func (_c *MockAPIClient_ContainerWait_Call) Return(waitResponseCh <-chan container.WaitResponse, errCh <-chan error) *MockAPIClient_ContainerWait_Call

+ func (_c *MockAPIClient_ContainerWait_Call) Run(...) *MockAPIClient_ContainerWait_Call

+ func (_c *MockAPIClient_ContainerWait_Call) RunAndReturn(...) *MockAPIClient_ContainerWait_Call

+ type MockAPIClient_ContainersPrune_Call struct

+ func (_c *MockAPIClient_ContainersPrune_Call) Return(pruneReport container.PruneReport, err error) *MockAPIClient_ContainersPrune_Call

+ func (_c *MockAPIClient_ContainersPrune_Call) Run(run func(ctx context.Context, pruneFilters filters.Args)) *MockAPIClient_ContainersPrune_Call

+ func (_c *MockAPIClient_ContainersPrune_Call) RunAndReturn(...) *MockAPIClient_ContainersPrune_Call

+ type MockAPIClient_CopyFromContainer_Call struct

+ func (_c *MockAPIClient_CopyFromContainer_Call) Return(readCloser io.ReadCloser, pathStat container.PathStat, err error) *MockAPIClient_CopyFromContainer_Call

+ func (_c *MockAPIClient_CopyFromContainer_Call) Run(run func(ctx context.Context, container1 string, srcPath string)) *MockAPIClient_CopyFromContainer_Call

+ func (_c *MockAPIClient_CopyFromContainer_Call) RunAndReturn(...) *MockAPIClient_CopyFromContainer_Call

+ type MockAPIClient_CopyToContainer_Call struct

+ func (_c *MockAPIClient_CopyToContainer_Call) Return(err error) *MockAPIClient_CopyToContainer_Call

+ func (_c *MockAPIClient_CopyToContainer_Call) Run(...) *MockAPIClient_CopyToContainer_Call

+ func (_c *MockAPIClient_CopyToContainer_Call) RunAndReturn(...) *MockAPIClient_CopyToContainer_Call

+ type MockAPIClient_DaemonHost_Call struct

+ func (_c *MockAPIClient_DaemonHost_Call) Return(s string) *MockAPIClient_DaemonHost_Call

+ func (_c *MockAPIClient_DaemonHost_Call) Run(run func()) *MockAPIClient_DaemonHost_Call

+ func (_c *MockAPIClient_DaemonHost_Call) RunAndReturn(run func() string) *MockAPIClient_DaemonHost_Call

+ type MockAPIClient_DialHijack_Call struct

+ func (_c *MockAPIClient_DialHijack_Call) Return(conn net.Conn, err error) *MockAPIClient_DialHijack_Call

+ func (_c *MockAPIClient_DialHijack_Call) Run(...) *MockAPIClient_DialHijack_Call

+ func (_c *MockAPIClient_DialHijack_Call) RunAndReturn(...) *MockAPIClient_DialHijack_Call

+ type MockAPIClient_Dialer_Call struct

+ func (_c *MockAPIClient_Dialer_Call) Return(fn func(context.Context) (net.Conn, error)) *MockAPIClient_Dialer_Call

+ func (_c *MockAPIClient_Dialer_Call) Run(run func()) *MockAPIClient_Dialer_Call

+ func (_c *MockAPIClient_Dialer_Call) RunAndReturn(run func() func(context.Context) (net.Conn, error)) *MockAPIClient_Dialer_Call

+ type MockAPIClient_DiskUsage_Call struct

+ func (_c *MockAPIClient_DiskUsage_Call) Return(diskUsage types.DiskUsage, err error) *MockAPIClient_DiskUsage_Call

+ func (_c *MockAPIClient_DiskUsage_Call) Run(run func(ctx context.Context, options types.DiskUsageOptions)) *MockAPIClient_DiskUsage_Call

+ func (_c *MockAPIClient_DiskUsage_Call) RunAndReturn(...) *MockAPIClient_DiskUsage_Call

+ type MockAPIClient_DistributionInspect_Call struct

+ func (_c *MockAPIClient_DistributionInspect_Call) Return(distributionInspect registry.DistributionInspect, err error) *MockAPIClient_DistributionInspect_Call

+ func (_c *MockAPIClient_DistributionInspect_Call) Run(run func(ctx context.Context, image string, encodedRegistryAuth string)) *MockAPIClient_DistributionInspect_Call

+ func (_c *MockAPIClient_DistributionInspect_Call) RunAndReturn(...) *MockAPIClient_DistributionInspect_Call

+ type MockAPIClient_Events_Call struct

+ func (_c *MockAPIClient_Events_Call) Return(messageCh <-chan events.Message, errCh <-chan error) *MockAPIClient_Events_Call

+ func (_c *MockAPIClient_Events_Call) Run(run func(ctx context.Context, options events.ListOptions)) *MockAPIClient_Events_Call

+ func (_c *MockAPIClient_Events_Call) RunAndReturn(...) *MockAPIClient_Events_Call

+ type MockAPIClient_Expecter struct

+ func (_e *MockAPIClient_Expecter) BuildCachePrune(ctx interface{}, opts interface{}) *MockAPIClient_BuildCachePrune_Call

+ func (_e *MockAPIClient_Expecter) BuildCancel(ctx interface{}, id interface{}) *MockAPIClient_BuildCancel_Call

+ func (_e *MockAPIClient_Expecter) CheckpointCreate(ctx interface{}, container interface{}, options interface{}) *MockAPIClient_CheckpointCreate_Call

+ func (_e *MockAPIClient_Expecter) CheckpointDelete(ctx interface{}, container interface{}, options interface{}) *MockAPIClient_CheckpointDelete_Call

+ func (_e *MockAPIClient_Expecter) CheckpointList(ctx interface{}, container interface{}, options interface{}) *MockAPIClient_CheckpointList_Call

+ func (_e *MockAPIClient_Expecter) ClientVersion() *MockAPIClient_ClientVersion_Call

+ func (_e *MockAPIClient_Expecter) Close() *MockAPIClient_Close_Call

+ func (_e *MockAPIClient_Expecter) ConfigCreate(ctx interface{}, config interface{}) *MockAPIClient_ConfigCreate_Call

+ func (_e *MockAPIClient_Expecter) ConfigInspectWithRaw(ctx interface{}, name interface{}) *MockAPIClient_ConfigInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) ConfigList(ctx interface{}, options interface{}) *MockAPIClient_ConfigList_Call

+ func (_e *MockAPIClient_Expecter) ConfigRemove(ctx interface{}, id interface{}) *MockAPIClient_ConfigRemove_Call

+ func (_e *MockAPIClient_Expecter) ConfigUpdate(ctx interface{}, id interface{}, version interface{}, config interface{}) *MockAPIClient_ConfigUpdate_Call

+ func (_e *MockAPIClient_Expecter) ContainerAttach(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerAttach_Call

+ func (_e *MockAPIClient_Expecter) ContainerCommit(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerCommit_Call

+ func (_e *MockAPIClient_Expecter) ContainerCreate(ctx interface{}, config interface{}, hostConfig interface{}, ...) *MockAPIClient_ContainerCreate_Call

+ func (_e *MockAPIClient_Expecter) ContainerDiff(ctx interface{}, container1 interface{}) *MockAPIClient_ContainerDiff_Call

+ func (_e *MockAPIClient_Expecter) ContainerExecAttach(ctx interface{}, execID interface{}, options interface{}) *MockAPIClient_ContainerExecAttach_Call

+ func (_e *MockAPIClient_Expecter) ContainerExecCreate(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerExecCreate_Call

+ func (_e *MockAPIClient_Expecter) ContainerExecInspect(ctx interface{}, execID interface{}) *MockAPIClient_ContainerExecInspect_Call

+ func (_e *MockAPIClient_Expecter) ContainerExecResize(ctx interface{}, execID interface{}, options interface{}) *MockAPIClient_ContainerExecResize_Call

+ func (_e *MockAPIClient_Expecter) ContainerExecStart(ctx interface{}, execID interface{}, options interface{}) *MockAPIClient_ContainerExecStart_Call

+ func (_e *MockAPIClient_Expecter) ContainerExport(ctx interface{}, container1 interface{}) *MockAPIClient_ContainerExport_Call

+ func (_e *MockAPIClient_Expecter) ContainerInspect(ctx interface{}, container1 interface{}) *MockAPIClient_ContainerInspect_Call

+ func (_e *MockAPIClient_Expecter) ContainerInspectWithRaw(ctx interface{}, container1 interface{}, getSize interface{}) *MockAPIClient_ContainerInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) ContainerKill(ctx interface{}, container1 interface{}, signal interface{}) *MockAPIClient_ContainerKill_Call

+ func (_e *MockAPIClient_Expecter) ContainerList(ctx interface{}, options interface{}) *MockAPIClient_ContainerList_Call

+ func (_e *MockAPIClient_Expecter) ContainerLogs(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerLogs_Call

+ func (_e *MockAPIClient_Expecter) ContainerPause(ctx interface{}, container1 interface{}) *MockAPIClient_ContainerPause_Call

+ func (_e *MockAPIClient_Expecter) ContainerRemove(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerRemove_Call

+ func (_e *MockAPIClient_Expecter) ContainerRename(ctx interface{}, container1 interface{}, newContainerName interface{}) *MockAPIClient_ContainerRename_Call

+ func (_e *MockAPIClient_Expecter) ContainerResize(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerResize_Call

+ func (_e *MockAPIClient_Expecter) ContainerRestart(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerRestart_Call

+ func (_e *MockAPIClient_Expecter) ContainerStart(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerStart_Call

+ func (_e *MockAPIClient_Expecter) ContainerStatPath(ctx interface{}, container1 interface{}, path interface{}) *MockAPIClient_ContainerStatPath_Call

+ func (_e *MockAPIClient_Expecter) ContainerStats(ctx interface{}, container1 interface{}, stream interface{}) *MockAPIClient_ContainerStats_Call

+ func (_e *MockAPIClient_Expecter) ContainerStatsOneShot(ctx interface{}, container1 interface{}) *MockAPIClient_ContainerStatsOneShot_Call

+ func (_e *MockAPIClient_Expecter) ContainerStop(ctx interface{}, container1 interface{}, options interface{}) *MockAPIClient_ContainerStop_Call

+ func (_e *MockAPIClient_Expecter) ContainerTop(ctx interface{}, container1 interface{}, arguments interface{}) *MockAPIClient_ContainerTop_Call

+ func (_e *MockAPIClient_Expecter) ContainerUnpause(ctx interface{}, container1 interface{}) *MockAPIClient_ContainerUnpause_Call

+ func (_e *MockAPIClient_Expecter) ContainerUpdate(ctx interface{}, container1 interface{}, updateConfig interface{}) *MockAPIClient_ContainerUpdate_Call

+ func (_e *MockAPIClient_Expecter) ContainerWait(ctx interface{}, container1 interface{}, condition interface{}) *MockAPIClient_ContainerWait_Call

+ func (_e *MockAPIClient_Expecter) ContainersPrune(ctx interface{}, pruneFilters interface{}) *MockAPIClient_ContainersPrune_Call

+ func (_e *MockAPIClient_Expecter) CopyFromContainer(ctx interface{}, container1 interface{}, srcPath interface{}) *MockAPIClient_CopyFromContainer_Call

+ func (_e *MockAPIClient_Expecter) CopyToContainer(ctx interface{}, container1 interface{}, path interface{}, content interface{}, ...) *MockAPIClient_CopyToContainer_Call

+ func (_e *MockAPIClient_Expecter) DaemonHost() *MockAPIClient_DaemonHost_Call

+ func (_e *MockAPIClient_Expecter) DialHijack(ctx interface{}, url interface{}, proto interface{}, meta interface{}) *MockAPIClient_DialHijack_Call

+ func (_e *MockAPIClient_Expecter) Dialer() *MockAPIClient_Dialer_Call

+ func (_e *MockAPIClient_Expecter) DiskUsage(ctx interface{}, options interface{}) *MockAPIClient_DiskUsage_Call

+ func (_e *MockAPIClient_Expecter) DistributionInspect(ctx interface{}, image interface{}, encodedRegistryAuth interface{}) *MockAPIClient_DistributionInspect_Call

+ func (_e *MockAPIClient_Expecter) Events(ctx interface{}, options interface{}) *MockAPIClient_Events_Call

+ func (_e *MockAPIClient_Expecter) HTTPClient() *MockAPIClient_HTTPClient_Call

+ func (_e *MockAPIClient_Expecter) ImageBuild(ctx interface{}, context1 interface{}, options interface{}) *MockAPIClient_ImageBuild_Call

+ func (_e *MockAPIClient_Expecter) ImageCreate(ctx interface{}, parentReference interface{}, options interface{}) *MockAPIClient_ImageCreate_Call

+ func (_e *MockAPIClient_Expecter) ImageHistory(ctx interface{}, image1 interface{}, imageHistoryOptions ...interface{}) *MockAPIClient_ImageHistory_Call

+ func (_e *MockAPIClient_Expecter) ImageImport(ctx interface{}, source interface{}, ref interface{}, options interface{}) *MockAPIClient_ImageImport_Call

+ func (_e *MockAPIClient_Expecter) ImageInspect(ctx interface{}, image1 interface{}, imageInspectOptions ...interface{}) *MockAPIClient_ImageInspect_Call

+ func (_e *MockAPIClient_Expecter) ImageInspectWithRaw(ctx interface{}, image1 interface{}) *MockAPIClient_ImageInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) ImageList(ctx interface{}, options interface{}) *MockAPIClient_ImageList_Call

+ func (_e *MockAPIClient_Expecter) ImageLoad(ctx interface{}, input interface{}, imageLoadOptions ...interface{}) *MockAPIClient_ImageLoad_Call

+ func (_e *MockAPIClient_Expecter) ImagePull(ctx interface{}, ref interface{}, options interface{}) *MockAPIClient_ImagePull_Call

+ func (_e *MockAPIClient_Expecter) ImagePush(ctx interface{}, ref interface{}, options interface{}) *MockAPIClient_ImagePush_Call

+ func (_e *MockAPIClient_Expecter) ImageRemove(ctx interface{}, image1 interface{}, options interface{}) *MockAPIClient_ImageRemove_Call

+ func (_e *MockAPIClient_Expecter) ImageSave(ctx interface{}, images interface{}, imageSaveOptions ...interface{}) *MockAPIClient_ImageSave_Call

+ func (_e *MockAPIClient_Expecter) ImageSearch(ctx interface{}, term interface{}, options interface{}) *MockAPIClient_ImageSearch_Call

+ func (_e *MockAPIClient_Expecter) ImageTag(ctx interface{}, image1 interface{}, ref interface{}) *MockAPIClient_ImageTag_Call

+ func (_e *MockAPIClient_Expecter) ImagesPrune(ctx interface{}, pruneFilter interface{}) *MockAPIClient_ImagesPrune_Call

+ func (_e *MockAPIClient_Expecter) Info(ctx interface{}) *MockAPIClient_Info_Call

+ func (_e *MockAPIClient_Expecter) NegotiateAPIVersion(ctx interface{}) *MockAPIClient_NegotiateAPIVersion_Call

+ func (_e *MockAPIClient_Expecter) NegotiateAPIVersionPing(ping interface{}) *MockAPIClient_NegotiateAPIVersionPing_Call

+ func (_e *MockAPIClient_Expecter) NetworkConnect(ctx interface{}, network1 interface{}, container1 interface{}, ...) *MockAPIClient_NetworkConnect_Call

+ func (_e *MockAPIClient_Expecter) NetworkCreate(ctx interface{}, name interface{}, options interface{}) *MockAPIClient_NetworkCreate_Call

+ func (_e *MockAPIClient_Expecter) NetworkDisconnect(ctx interface{}, network1 interface{}, container1 interface{}, ...) *MockAPIClient_NetworkDisconnect_Call

+ func (_e *MockAPIClient_Expecter) NetworkInspect(ctx interface{}, network1 interface{}, options interface{}) *MockAPIClient_NetworkInspect_Call

+ func (_e *MockAPIClient_Expecter) NetworkInspectWithRaw(ctx interface{}, network1 interface{}, options interface{}) *MockAPIClient_NetworkInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) NetworkList(ctx interface{}, options interface{}) *MockAPIClient_NetworkList_Call

+ func (_e *MockAPIClient_Expecter) NetworkRemove(ctx interface{}, network1 interface{}) *MockAPIClient_NetworkRemove_Call

+ func (_e *MockAPIClient_Expecter) NetworksPrune(ctx interface{}, pruneFilter interface{}) *MockAPIClient_NetworksPrune_Call

+ func (_e *MockAPIClient_Expecter) NodeInspectWithRaw(ctx interface{}, nodeID interface{}) *MockAPIClient_NodeInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) NodeList(ctx interface{}, options interface{}) *MockAPIClient_NodeList_Call

+ func (_e *MockAPIClient_Expecter) NodeRemove(ctx interface{}, nodeID interface{}, options interface{}) *MockAPIClient_NodeRemove_Call

+ func (_e *MockAPIClient_Expecter) NodeUpdate(ctx interface{}, nodeID interface{}, version interface{}, node interface{}) *MockAPIClient_NodeUpdate_Call

+ func (_e *MockAPIClient_Expecter) Ping(ctx interface{}) *MockAPIClient_Ping_Call

+ func (_e *MockAPIClient_Expecter) PluginCreate(ctx interface{}, createContext interface{}, options interface{}) *MockAPIClient_PluginCreate_Call

+ func (_e *MockAPIClient_Expecter) PluginDisable(ctx interface{}, name interface{}, options interface{}) *MockAPIClient_PluginDisable_Call

+ func (_e *MockAPIClient_Expecter) PluginEnable(ctx interface{}, name interface{}, options interface{}) *MockAPIClient_PluginEnable_Call

+ func (_e *MockAPIClient_Expecter) PluginInspectWithRaw(ctx interface{}, name interface{}) *MockAPIClient_PluginInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) PluginInstall(ctx interface{}, name interface{}, options interface{}) *MockAPIClient_PluginInstall_Call

+ func (_e *MockAPIClient_Expecter) PluginList(ctx interface{}, filter interface{}) *MockAPIClient_PluginList_Call

+ func (_e *MockAPIClient_Expecter) PluginPush(ctx interface{}, name interface{}, registryAuth interface{}) *MockAPIClient_PluginPush_Call

+ func (_e *MockAPIClient_Expecter) PluginRemove(ctx interface{}, name interface{}, options interface{}) *MockAPIClient_PluginRemove_Call

+ func (_e *MockAPIClient_Expecter) PluginSet(ctx interface{}, name interface{}, args interface{}) *MockAPIClient_PluginSet_Call

+ func (_e *MockAPIClient_Expecter) PluginUpgrade(ctx interface{}, name interface{}, options interface{}) *MockAPIClient_PluginUpgrade_Call

+ func (_e *MockAPIClient_Expecter) RegistryLogin(ctx interface{}, auth interface{}) *MockAPIClient_RegistryLogin_Call

+ func (_e *MockAPIClient_Expecter) SecretCreate(ctx interface{}, secret interface{}) *MockAPIClient_SecretCreate_Call

+ func (_e *MockAPIClient_Expecter) SecretInspectWithRaw(ctx interface{}, name interface{}) *MockAPIClient_SecretInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) SecretList(ctx interface{}, options interface{}) *MockAPIClient_SecretList_Call

+ func (_e *MockAPIClient_Expecter) SecretRemove(ctx interface{}, id interface{}) *MockAPIClient_SecretRemove_Call

+ func (_e *MockAPIClient_Expecter) SecretUpdate(ctx interface{}, id interface{}, version interface{}, secret interface{}) *MockAPIClient_SecretUpdate_Call

+ func (_e *MockAPIClient_Expecter) ServerVersion(ctx interface{}) *MockAPIClient_ServerVersion_Call

+ func (_e *MockAPIClient_Expecter) ServiceCreate(ctx interface{}, service interface{}, options interface{}) *MockAPIClient_ServiceCreate_Call

+ func (_e *MockAPIClient_Expecter) ServiceInspectWithRaw(ctx interface{}, serviceID interface{}, options interface{}) *MockAPIClient_ServiceInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) ServiceList(ctx interface{}, options interface{}) *MockAPIClient_ServiceList_Call

+ func (_e *MockAPIClient_Expecter) ServiceLogs(ctx interface{}, serviceID interface{}, options interface{}) *MockAPIClient_ServiceLogs_Call

+ func (_e *MockAPIClient_Expecter) ServiceRemove(ctx interface{}, serviceID interface{}) *MockAPIClient_ServiceRemove_Call

+ func (_e *MockAPIClient_Expecter) ServiceUpdate(ctx interface{}, serviceID interface{}, version interface{}, ...) *MockAPIClient_ServiceUpdate_Call

+ func (_e *MockAPIClient_Expecter) SwarmGetUnlockKey(ctx interface{}) *MockAPIClient_SwarmGetUnlockKey_Call

+ func (_e *MockAPIClient_Expecter) SwarmInit(ctx interface{}, req interface{}) *MockAPIClient_SwarmInit_Call

+ func (_e *MockAPIClient_Expecter) SwarmInspect(ctx interface{}) *MockAPIClient_SwarmInspect_Call

+ func (_e *MockAPIClient_Expecter) SwarmJoin(ctx interface{}, req interface{}) *MockAPIClient_SwarmJoin_Call

+ func (_e *MockAPIClient_Expecter) SwarmLeave(ctx interface{}, force interface{}) *MockAPIClient_SwarmLeave_Call

+ func (_e *MockAPIClient_Expecter) SwarmUnlock(ctx interface{}, req interface{}) *MockAPIClient_SwarmUnlock_Call

+ func (_e *MockAPIClient_Expecter) SwarmUpdate(ctx interface{}, version interface{}, swarm1 interface{}, flags interface{}) *MockAPIClient_SwarmUpdate_Call

+ func (_e *MockAPIClient_Expecter) TaskInspectWithRaw(ctx interface{}, taskID interface{}) *MockAPIClient_TaskInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) TaskList(ctx interface{}, options interface{}) *MockAPIClient_TaskList_Call

+ func (_e *MockAPIClient_Expecter) TaskLogs(ctx interface{}, taskID interface{}, options interface{}) *MockAPIClient_TaskLogs_Call

+ func (_e *MockAPIClient_Expecter) VolumeCreate(ctx interface{}, options interface{}) *MockAPIClient_VolumeCreate_Call

+ func (_e *MockAPIClient_Expecter) VolumeInspect(ctx interface{}, volumeID interface{}) *MockAPIClient_VolumeInspect_Call

+ func (_e *MockAPIClient_Expecter) VolumeInspectWithRaw(ctx interface{}, volumeID interface{}) *MockAPIClient_VolumeInspectWithRaw_Call

+ func (_e *MockAPIClient_Expecter) VolumeList(ctx interface{}, options interface{}) *MockAPIClient_VolumeList_Call

+ func (_e *MockAPIClient_Expecter) VolumeRemove(ctx interface{}, volumeID interface{}, force interface{}) *MockAPIClient_VolumeRemove_Call

+ func (_e *MockAPIClient_Expecter) VolumeUpdate(ctx interface{}, volumeID interface{}, version interface{}, ...) *MockAPIClient_VolumeUpdate_Call

+ func (_e *MockAPIClient_Expecter) VolumesPrune(ctx interface{}, pruneFilter interface{}) *MockAPIClient_VolumesPrune_Call

+ type MockAPIClient_HTTPClient_Call struct

+ func (_c *MockAPIClient_HTTPClient_Call) Return(client *http.Client) *MockAPIClient_HTTPClient_Call

+ func (_c *MockAPIClient_HTTPClient_Call) Run(run func()) *MockAPIClient_HTTPClient_Call

+ func (_c *MockAPIClient_HTTPClient_Call) RunAndReturn(run func() *http.Client) *MockAPIClient_HTTPClient_Call

+ type MockAPIClient_ImageBuild_Call struct

+ func (_c *MockAPIClient_ImageBuild_Call) Return(imageBuildResponse build.ImageBuildResponse, err error) *MockAPIClient_ImageBuild_Call

+ func (_c *MockAPIClient_ImageBuild_Call) Run(...) *MockAPIClient_ImageBuild_Call

+ func (_c *MockAPIClient_ImageBuild_Call) RunAndReturn(...) *MockAPIClient_ImageBuild_Call

+ type MockAPIClient_ImageCreate_Call struct

+ func (_c *MockAPIClient_ImageCreate_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImageCreate_Call

+ func (_c *MockAPIClient_ImageCreate_Call) Run(...) *MockAPIClient_ImageCreate_Call

+ func (_c *MockAPIClient_ImageCreate_Call) RunAndReturn(...) *MockAPIClient_ImageCreate_Call

+ type MockAPIClient_ImageHistory_Call struct

+ func (_c *MockAPIClient_ImageHistory_Call) Return(historyResponseItems []image.HistoryResponseItem, err error) *MockAPIClient_ImageHistory_Call

+ func (_c *MockAPIClient_ImageHistory_Call) Run(run func(ctx context.Context, image1 string, ...)) *MockAPIClient_ImageHistory_Call

+ func (_c *MockAPIClient_ImageHistory_Call) RunAndReturn(...) *MockAPIClient_ImageHistory_Call

+ type MockAPIClient_ImageImport_Call struct

+ func (_c *MockAPIClient_ImageImport_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImageImport_Call

+ func (_c *MockAPIClient_ImageImport_Call) Run(run func(ctx context.Context, source image.ImportSource, ref string, ...)) *MockAPIClient_ImageImport_Call

+ func (_c *MockAPIClient_ImageImport_Call) RunAndReturn(...) *MockAPIClient_ImageImport_Call

+ type MockAPIClient_ImageInspectWithRaw_Call struct

+ func (_c *MockAPIClient_ImageInspectWithRaw_Call) Return(inspectResponse image.InspectResponse, bytes []byte, err error) *MockAPIClient_ImageInspectWithRaw_Call

+ func (_c *MockAPIClient_ImageInspectWithRaw_Call) Run(run func(ctx context.Context, image1 string)) *MockAPIClient_ImageInspectWithRaw_Call

+ func (_c *MockAPIClient_ImageInspectWithRaw_Call) RunAndReturn(...) *MockAPIClient_ImageInspectWithRaw_Call

+ type MockAPIClient_ImageInspect_Call struct

+ func (_c *MockAPIClient_ImageInspect_Call) Return(inspectResponse image.InspectResponse, err error) *MockAPIClient_ImageInspect_Call

+ func (_c *MockAPIClient_ImageInspect_Call) Run(run func(ctx context.Context, image1 string, ...)) *MockAPIClient_ImageInspect_Call

+ func (_c *MockAPIClient_ImageInspect_Call) RunAndReturn(...) *MockAPIClient_ImageInspect_Call

+ type MockAPIClient_ImageList_Call struct

+ func (_c *MockAPIClient_ImageList_Call) Return(summarys []image.Summary, err error) *MockAPIClient_ImageList_Call

+ func (_c *MockAPIClient_ImageList_Call) Run(run func(ctx context.Context, options image.ListOptions)) *MockAPIClient_ImageList_Call

+ func (_c *MockAPIClient_ImageList_Call) RunAndReturn(...) *MockAPIClient_ImageList_Call

+ type MockAPIClient_ImageLoad_Call struct

+ func (_c *MockAPIClient_ImageLoad_Call) Return(loadResponse image.LoadResponse, err error) *MockAPIClient_ImageLoad_Call

+ func (_c *MockAPIClient_ImageLoad_Call) Run(run func(ctx context.Context, input io.Reader, ...)) *MockAPIClient_ImageLoad_Call

+ func (_c *MockAPIClient_ImageLoad_Call) RunAndReturn(...) *MockAPIClient_ImageLoad_Call

+ type MockAPIClient_ImagePull_Call struct

+ func (_c *MockAPIClient_ImagePull_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImagePull_Call

+ func (_c *MockAPIClient_ImagePull_Call) Run(run func(ctx context.Context, ref string, options image.PullOptions)) *MockAPIClient_ImagePull_Call

+ func (_c *MockAPIClient_ImagePull_Call) RunAndReturn(...) *MockAPIClient_ImagePull_Call

+ type MockAPIClient_ImagePush_Call struct

+ func (_c *MockAPIClient_ImagePush_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImagePush_Call

+ func (_c *MockAPIClient_ImagePush_Call) Run(run func(ctx context.Context, ref string, options image.PushOptions)) *MockAPIClient_ImagePush_Call

+ func (_c *MockAPIClient_ImagePush_Call) RunAndReturn(...) *MockAPIClient_ImagePush_Call

+ type MockAPIClient_ImageRemove_Call struct

+ func (_c *MockAPIClient_ImageRemove_Call) Return(deleteResponses []image.DeleteResponse, err error) *MockAPIClient_ImageRemove_Call

+ func (_c *MockAPIClient_ImageRemove_Call) Run(run func(ctx context.Context, image1 string, options image.RemoveOptions)) *MockAPIClient_ImageRemove_Call

+ func (_c *MockAPIClient_ImageRemove_Call) RunAndReturn(...) *MockAPIClient_ImageRemove_Call

+ type MockAPIClient_ImageSave_Call struct

+ func (_c *MockAPIClient_ImageSave_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImageSave_Call

+ func (_c *MockAPIClient_ImageSave_Call) Run(run func(ctx context.Context, images []string, ...)) *MockAPIClient_ImageSave_Call

+ func (_c *MockAPIClient_ImageSave_Call) RunAndReturn(run func(ctx context.Context, images []string, ...) (io.ReadCloser, error)) *MockAPIClient_ImageSave_Call

+ type MockAPIClient_ImageSearch_Call struct

+ func (_c *MockAPIClient_ImageSearch_Call) Return(searchResults []registry.SearchResult, err error) *MockAPIClient_ImageSearch_Call

+ func (_c *MockAPIClient_ImageSearch_Call) Run(run func(ctx context.Context, term string, options registry.SearchOptions)) *MockAPIClient_ImageSearch_Call

+ func (_c *MockAPIClient_ImageSearch_Call) RunAndReturn(...) *MockAPIClient_ImageSearch_Call

+ type MockAPIClient_ImageTag_Call struct

+ func (_c *MockAPIClient_ImageTag_Call) Return(err error) *MockAPIClient_ImageTag_Call

+ func (_c *MockAPIClient_ImageTag_Call) Run(run func(ctx context.Context, image1 string, ref string)) *MockAPIClient_ImageTag_Call

+ func (_c *MockAPIClient_ImageTag_Call) RunAndReturn(run func(ctx context.Context, image1 string, ref string) error) *MockAPIClient_ImageTag_Call

+ type MockAPIClient_ImagesPrune_Call struct

+ func (_c *MockAPIClient_ImagesPrune_Call) Return(pruneReport image.PruneReport, err error) *MockAPIClient_ImagesPrune_Call

+ func (_c *MockAPIClient_ImagesPrune_Call) Run(run func(ctx context.Context, pruneFilter filters.Args)) *MockAPIClient_ImagesPrune_Call

+ func (_c *MockAPIClient_ImagesPrune_Call) RunAndReturn(...) *MockAPIClient_ImagesPrune_Call

+ type MockAPIClient_Info_Call struct

+ func (_c *MockAPIClient_Info_Call) Return(info system.Info, err error) *MockAPIClient_Info_Call

+ func (_c *MockAPIClient_Info_Call) Run(run func(ctx context.Context)) *MockAPIClient_Info_Call

+ func (_c *MockAPIClient_Info_Call) RunAndReturn(run func(ctx context.Context) (system.Info, error)) *MockAPIClient_Info_Call

+ type MockAPIClient_NegotiateAPIVersionPing_Call struct

+ func (_c *MockAPIClient_NegotiateAPIVersionPing_Call) Return() *MockAPIClient_NegotiateAPIVersionPing_Call

+ func (_c *MockAPIClient_NegotiateAPIVersionPing_Call) Run(run func(ping types.Ping)) *MockAPIClient_NegotiateAPIVersionPing_Call

+ func (_c *MockAPIClient_NegotiateAPIVersionPing_Call) RunAndReturn(run func(ping types.Ping)) *MockAPIClient_NegotiateAPIVersionPing_Call

+ type MockAPIClient_NegotiateAPIVersion_Call struct

+ func (_c *MockAPIClient_NegotiateAPIVersion_Call) Return() *MockAPIClient_NegotiateAPIVersion_Call

+ func (_c *MockAPIClient_NegotiateAPIVersion_Call) Run(run func(ctx context.Context)) *MockAPIClient_NegotiateAPIVersion_Call

+ func (_c *MockAPIClient_NegotiateAPIVersion_Call) RunAndReturn(run func(ctx context.Context)) *MockAPIClient_NegotiateAPIVersion_Call

+ type MockAPIClient_NetworkConnect_Call struct

+ func (_c *MockAPIClient_NetworkConnect_Call) Return(err error) *MockAPIClient_NetworkConnect_Call

+ func (_c *MockAPIClient_NetworkConnect_Call) Run(run func(ctx context.Context, network1 string, container1 string, ...)) *MockAPIClient_NetworkConnect_Call

+ func (_c *MockAPIClient_NetworkConnect_Call) RunAndReturn(run func(ctx context.Context, network1 string, container1 string, ...) error) *MockAPIClient_NetworkConnect_Call

+ type MockAPIClient_NetworkCreate_Call struct

+ func (_c *MockAPIClient_NetworkCreate_Call) Return(createResponse network.CreateResponse, err error) *MockAPIClient_NetworkCreate_Call

+ func (_c *MockAPIClient_NetworkCreate_Call) Run(run func(ctx context.Context, name string, options network.CreateOptions)) *MockAPIClient_NetworkCreate_Call

+ func (_c *MockAPIClient_NetworkCreate_Call) RunAndReturn(...) *MockAPIClient_NetworkCreate_Call

+ type MockAPIClient_NetworkDisconnect_Call struct

+ func (_c *MockAPIClient_NetworkDisconnect_Call) Return(err error) *MockAPIClient_NetworkDisconnect_Call

+ func (_c *MockAPIClient_NetworkDisconnect_Call) Run(run func(ctx context.Context, network1 string, container1 string, force bool)) *MockAPIClient_NetworkDisconnect_Call

+ func (_c *MockAPIClient_NetworkDisconnect_Call) RunAndReturn(...) *MockAPIClient_NetworkDisconnect_Call

+ type MockAPIClient_NetworkInspectWithRaw_Call struct

+ func (_c *MockAPIClient_NetworkInspectWithRaw_Call) Return(inspect network.Inspect, bytes []byte, err error) *MockAPIClient_NetworkInspectWithRaw_Call

+ func (_c *MockAPIClient_NetworkInspectWithRaw_Call) Run(run func(ctx context.Context, network1 string, options network.InspectOptions)) *MockAPIClient_NetworkInspectWithRaw_Call

+ func (_c *MockAPIClient_NetworkInspectWithRaw_Call) RunAndReturn(...) *MockAPIClient_NetworkInspectWithRaw_Call

+ type MockAPIClient_NetworkInspect_Call struct

+ func (_c *MockAPIClient_NetworkInspect_Call) Return(inspect network.Inspect, err error) *MockAPIClient_NetworkInspect_Call

+ func (_c *MockAPIClient_NetworkInspect_Call) Run(run func(ctx context.Context, network1 string, options network.InspectOptions)) *MockAPIClient_NetworkInspect_Call

+ func (_c *MockAPIClient_NetworkInspect_Call) RunAndReturn(...) *MockAPIClient_NetworkInspect_Call

+ type MockAPIClient_NetworkList_Call struct

+ func (_c *MockAPIClient_NetworkList_Call) Return(vs []network.Summary, err error) *MockAPIClient_NetworkList_Call

+ func (_c *MockAPIClient_NetworkList_Call) Run(run func(ctx context.Context, options network.ListOptions)) *MockAPIClient_NetworkList_Call

+ func (_c *MockAPIClient_NetworkList_Call) RunAndReturn(...) *MockAPIClient_NetworkList_Call

+ type MockAPIClient_NetworkRemove_Call struct

+ func (_c *MockAPIClient_NetworkRemove_Call) Return(err error) *MockAPIClient_NetworkRemove_Call

+ func (_c *MockAPIClient_NetworkRemove_Call) Run(run func(ctx context.Context, network1 string)) *MockAPIClient_NetworkRemove_Call

+ func (_c *MockAPIClient_NetworkRemove_Call) RunAndReturn(run func(ctx context.Context, network1 string) error) *MockAPIClient_NetworkRemove_Call

+ type MockAPIClient_NetworksPrune_Call struct

+ func (_c *MockAPIClient_NetworksPrune_Call) Return(pruneReport network.PruneReport, err error) *MockAPIClient_NetworksPrune_Call

+ func (_c *MockAPIClient_NetworksPrune_Call) Run(run func(ctx context.Context, pruneFilter filters.Args)) *MockAPIClient_NetworksPrune_Call

+ func (_c *MockAPIClient_NetworksPrune_Call) RunAndReturn(...) *MockAPIClient_NetworksPrune_Call

+ type MockAPIClient_NodeInspectWithRaw_Call struct

+ func (_c *MockAPIClient_NodeInspectWithRaw_Call) Return(node swarm.Node, bytes []byte, err error) *MockAPIClient_NodeInspectWithRaw_Call

+ func (_c *MockAPIClient_NodeInspectWithRaw_Call) Run(run func(ctx context.Context, nodeID string)) *MockAPIClient_NodeInspectWithRaw_Call

+ func (_c *MockAPIClient_NodeInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, nodeID string) (swarm.Node, []byte, error)) *MockAPIClient_NodeInspectWithRaw_Call

+ type MockAPIClient_NodeList_Call struct

+ func (_c *MockAPIClient_NodeList_Call) Return(nodes []swarm.Node, err error) *MockAPIClient_NodeList_Call

+ func (_c *MockAPIClient_NodeList_Call) Run(run func(ctx context.Context, options swarm.NodeListOptions)) *MockAPIClient_NodeList_Call

+ func (_c *MockAPIClient_NodeList_Call) RunAndReturn(...) *MockAPIClient_NodeList_Call

+ type MockAPIClient_NodeRemove_Call struct

+ func (_c *MockAPIClient_NodeRemove_Call) Return(err error) *MockAPIClient_NodeRemove_Call

+ func (_c *MockAPIClient_NodeRemove_Call) Run(run func(ctx context.Context, nodeID string, options swarm.NodeRemoveOptions)) *MockAPIClient_NodeRemove_Call

+ func (_c *MockAPIClient_NodeRemove_Call) RunAndReturn(...) *MockAPIClient_NodeRemove_Call

+ type MockAPIClient_NodeUpdate_Call struct

+ func (_c *MockAPIClient_NodeUpdate_Call) Return(err error) *MockAPIClient_NodeUpdate_Call

+ func (_c *MockAPIClient_NodeUpdate_Call) Run(...) *MockAPIClient_NodeUpdate_Call

+ func (_c *MockAPIClient_NodeUpdate_Call) RunAndReturn(...) *MockAPIClient_NodeUpdate_Call

+ type MockAPIClient_Ping_Call struct

+ func (_c *MockAPIClient_Ping_Call) Return(ping types.Ping, err error) *MockAPIClient_Ping_Call

+ func (_c *MockAPIClient_Ping_Call) Run(run func(ctx context.Context)) *MockAPIClient_Ping_Call

+ func (_c *MockAPIClient_Ping_Call) RunAndReturn(run func(ctx context.Context) (types.Ping, error)) *MockAPIClient_Ping_Call

+ type MockAPIClient_PluginCreate_Call struct

+ func (_c *MockAPIClient_PluginCreate_Call) Return(err error) *MockAPIClient_PluginCreate_Call

+ func (_c *MockAPIClient_PluginCreate_Call) Run(run func(ctx context.Context, createContext io.Reader, ...)) *MockAPIClient_PluginCreate_Call

+ func (_c *MockAPIClient_PluginCreate_Call) RunAndReturn(run func(ctx context.Context, createContext io.Reader, ...) error) *MockAPIClient_PluginCreate_Call

+ type MockAPIClient_PluginDisable_Call struct

+ func (_c *MockAPIClient_PluginDisable_Call) Return(err error) *MockAPIClient_PluginDisable_Call

+ func (_c *MockAPIClient_PluginDisable_Call) Run(run func(ctx context.Context, name string, options types.PluginDisableOptions)) *MockAPIClient_PluginDisable_Call

+ func (_c *MockAPIClient_PluginDisable_Call) RunAndReturn(...) *MockAPIClient_PluginDisable_Call

+ type MockAPIClient_PluginEnable_Call struct

+ func (_c *MockAPIClient_PluginEnable_Call) Return(err error) *MockAPIClient_PluginEnable_Call

+ func (_c *MockAPIClient_PluginEnable_Call) Run(run func(ctx context.Context, name string, options types.PluginEnableOptions)) *MockAPIClient_PluginEnable_Call

+ func (_c *MockAPIClient_PluginEnable_Call) RunAndReturn(...) *MockAPIClient_PluginEnable_Call

+ type MockAPIClient_PluginInspectWithRaw_Call struct

+ func (_c *MockAPIClient_PluginInspectWithRaw_Call) Return(plugin *types.Plugin, bytes []byte, err error) *MockAPIClient_PluginInspectWithRaw_Call

+ func (_c *MockAPIClient_PluginInspectWithRaw_Call) Run(run func(ctx context.Context, name string)) *MockAPIClient_PluginInspectWithRaw_Call

+ func (_c *MockAPIClient_PluginInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, name string) (*types.Plugin, []byte, error)) *MockAPIClient_PluginInspectWithRaw_Call

+ type MockAPIClient_PluginInstall_Call struct

+ func (_c *MockAPIClient_PluginInstall_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_PluginInstall_Call

+ func (_c *MockAPIClient_PluginInstall_Call) Run(run func(ctx context.Context, name string, options types.PluginInstallOptions)) *MockAPIClient_PluginInstall_Call

+ func (_c *MockAPIClient_PluginInstall_Call) RunAndReturn(...) *MockAPIClient_PluginInstall_Call

+ type MockAPIClient_PluginList_Call struct

+ func (_c *MockAPIClient_PluginList_Call) Return(pluginsListResponse types.PluginsListResponse, err error) *MockAPIClient_PluginList_Call

+ func (_c *MockAPIClient_PluginList_Call) Run(run func(ctx context.Context, filter filters.Args)) *MockAPIClient_PluginList_Call

+ func (_c *MockAPIClient_PluginList_Call) RunAndReturn(...) *MockAPIClient_PluginList_Call

+ type MockAPIClient_PluginPush_Call struct

+ func (_c *MockAPIClient_PluginPush_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_PluginPush_Call

+ func (_c *MockAPIClient_PluginPush_Call) Run(run func(ctx context.Context, name string, registryAuth string)) *MockAPIClient_PluginPush_Call

+ func (_c *MockAPIClient_PluginPush_Call) RunAndReturn(...) *MockAPIClient_PluginPush_Call

+ type MockAPIClient_PluginRemove_Call struct

+ func (_c *MockAPIClient_PluginRemove_Call) Return(err error) *MockAPIClient_PluginRemove_Call

+ func (_c *MockAPIClient_PluginRemove_Call) Run(run func(ctx context.Context, name string, options types.PluginRemoveOptions)) *MockAPIClient_PluginRemove_Call

+ func (_c *MockAPIClient_PluginRemove_Call) RunAndReturn(...) *MockAPIClient_PluginRemove_Call

+ type MockAPIClient_PluginSet_Call struct

+ func (_c *MockAPIClient_PluginSet_Call) Return(err error) *MockAPIClient_PluginSet_Call

+ func (_c *MockAPIClient_PluginSet_Call) Run(run func(ctx context.Context, name string, args []string)) *MockAPIClient_PluginSet_Call

+ func (_c *MockAPIClient_PluginSet_Call) RunAndReturn(run func(ctx context.Context, name string, args []string) error) *MockAPIClient_PluginSet_Call

+ type MockAPIClient_PluginUpgrade_Call struct

+ func (_c *MockAPIClient_PluginUpgrade_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_PluginUpgrade_Call

+ func (_c *MockAPIClient_PluginUpgrade_Call) Run(run func(ctx context.Context, name string, options types.PluginInstallOptions)) *MockAPIClient_PluginUpgrade_Call

+ func (_c *MockAPIClient_PluginUpgrade_Call) RunAndReturn(...) *MockAPIClient_PluginUpgrade_Call

+ type MockAPIClient_RegistryLogin_Call struct

+ func (_c *MockAPIClient_RegistryLogin_Call) Return(authenticateOKBody registry.AuthenticateOKBody, err error) *MockAPIClient_RegistryLogin_Call

+ func (_c *MockAPIClient_RegistryLogin_Call) Run(run func(ctx context.Context, auth registry.AuthConfig)) *MockAPIClient_RegistryLogin_Call

+ func (_c *MockAPIClient_RegistryLogin_Call) RunAndReturn(...) *MockAPIClient_RegistryLogin_Call

+ type MockAPIClient_SecretCreate_Call struct

+ func (_c *MockAPIClient_SecretCreate_Call) Return(secretCreateResponse swarm.SecretCreateResponse, err error) *MockAPIClient_SecretCreate_Call

+ func (_c *MockAPIClient_SecretCreate_Call) Run(run func(ctx context.Context, secret swarm.SecretSpec)) *MockAPIClient_SecretCreate_Call

+ func (_c *MockAPIClient_SecretCreate_Call) RunAndReturn(...) *MockAPIClient_SecretCreate_Call

+ type MockAPIClient_SecretInspectWithRaw_Call struct

+ func (_c *MockAPIClient_SecretInspectWithRaw_Call) Return(secret swarm.Secret, bytes []byte, err error) *MockAPIClient_SecretInspectWithRaw_Call

+ func (_c *MockAPIClient_SecretInspectWithRaw_Call) Run(run func(ctx context.Context, name string)) *MockAPIClient_SecretInspectWithRaw_Call

+ func (_c *MockAPIClient_SecretInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, name string) (swarm.Secret, []byte, error)) *MockAPIClient_SecretInspectWithRaw_Call

+ type MockAPIClient_SecretList_Call struct

+ func (_c *MockAPIClient_SecretList_Call) Return(secrets []swarm.Secret, err error) *MockAPIClient_SecretList_Call

+ func (_c *MockAPIClient_SecretList_Call) Run(run func(ctx context.Context, options swarm.SecretListOptions)) *MockAPIClient_SecretList_Call

+ func (_c *MockAPIClient_SecretList_Call) RunAndReturn(...) *MockAPIClient_SecretList_Call

+ type MockAPIClient_SecretRemove_Call struct

+ func (_c *MockAPIClient_SecretRemove_Call) Return(err error) *MockAPIClient_SecretRemove_Call

+ func (_c *MockAPIClient_SecretRemove_Call) Run(run func(ctx context.Context, id string)) *MockAPIClient_SecretRemove_Call

+ func (_c *MockAPIClient_SecretRemove_Call) RunAndReturn(run func(ctx context.Context, id string) error) *MockAPIClient_SecretRemove_Call

+ type MockAPIClient_SecretUpdate_Call struct

+ func (_c *MockAPIClient_SecretUpdate_Call) Return(err error) *MockAPIClient_SecretUpdate_Call

+ func (_c *MockAPIClient_SecretUpdate_Call) Run(...) *MockAPIClient_SecretUpdate_Call

+ func (_c *MockAPIClient_SecretUpdate_Call) RunAndReturn(...) *MockAPIClient_SecretUpdate_Call

+ type MockAPIClient_ServerVersion_Call struct

+ func (_c *MockAPIClient_ServerVersion_Call) Return(version types.Version, err error) *MockAPIClient_ServerVersion_Call

+ func (_c *MockAPIClient_ServerVersion_Call) Run(run func(ctx context.Context)) *MockAPIClient_ServerVersion_Call

+ func (_c *MockAPIClient_ServerVersion_Call) RunAndReturn(run func(ctx context.Context) (types.Version, error)) *MockAPIClient_ServerVersion_Call

+ type MockAPIClient_ServiceCreate_Call struct

+ func (_c *MockAPIClient_ServiceCreate_Call) Return(serviceCreateResponse swarm.ServiceCreateResponse, err error) *MockAPIClient_ServiceCreate_Call

+ func (_c *MockAPIClient_ServiceCreate_Call) Run(run func(ctx context.Context, service swarm.ServiceSpec, ...)) *MockAPIClient_ServiceCreate_Call

+ func (_c *MockAPIClient_ServiceCreate_Call) RunAndReturn(...) *MockAPIClient_ServiceCreate_Call

+ type MockAPIClient_ServiceInspectWithRaw_Call struct

+ func (_c *MockAPIClient_ServiceInspectWithRaw_Call) Return(service swarm.Service, bytes []byte, err error) *MockAPIClient_ServiceInspectWithRaw_Call

+ func (_c *MockAPIClient_ServiceInspectWithRaw_Call) Run(...) *MockAPIClient_ServiceInspectWithRaw_Call

+ func (_c *MockAPIClient_ServiceInspectWithRaw_Call) RunAndReturn(...) *MockAPIClient_ServiceInspectWithRaw_Call

+ type MockAPIClient_ServiceList_Call struct

+ func (_c *MockAPIClient_ServiceList_Call) Return(services []swarm.Service, err error) *MockAPIClient_ServiceList_Call

+ func (_c *MockAPIClient_ServiceList_Call) Run(run func(ctx context.Context, options swarm.ServiceListOptions)) *MockAPIClient_ServiceList_Call

+ func (_c *MockAPIClient_ServiceList_Call) RunAndReturn(...) *MockAPIClient_ServiceList_Call

+ type MockAPIClient_ServiceLogs_Call struct

+ func (_c *MockAPIClient_ServiceLogs_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ServiceLogs_Call

+ func (_c *MockAPIClient_ServiceLogs_Call) Run(run func(ctx context.Context, serviceID string, options container.LogsOptions)) *MockAPIClient_ServiceLogs_Call

+ func (_c *MockAPIClient_ServiceLogs_Call) RunAndReturn(...) *MockAPIClient_ServiceLogs_Call

+ type MockAPIClient_ServiceRemove_Call struct

+ func (_c *MockAPIClient_ServiceRemove_Call) Return(err error) *MockAPIClient_ServiceRemove_Call

+ func (_c *MockAPIClient_ServiceRemove_Call) Run(run func(ctx context.Context, serviceID string)) *MockAPIClient_ServiceRemove_Call

+ func (_c *MockAPIClient_ServiceRemove_Call) RunAndReturn(run func(ctx context.Context, serviceID string) error) *MockAPIClient_ServiceRemove_Call

+ type MockAPIClient_ServiceUpdate_Call struct

+ func (_c *MockAPIClient_ServiceUpdate_Call) Return(serviceUpdateResponse swarm.ServiceUpdateResponse, err error) *MockAPIClient_ServiceUpdate_Call

+ func (_c *MockAPIClient_ServiceUpdate_Call) Run(run func(ctx context.Context, serviceID string, version swarm.Version, ...)) *MockAPIClient_ServiceUpdate_Call

+ func (_c *MockAPIClient_ServiceUpdate_Call) RunAndReturn(...) *MockAPIClient_ServiceUpdate_Call

+ type MockAPIClient_SwarmGetUnlockKey_Call struct

+ func (_c *MockAPIClient_SwarmGetUnlockKey_Call) Return(unlockKeyResponse swarm.UnlockKeyResponse, err error) *MockAPIClient_SwarmGetUnlockKey_Call

+ func (_c *MockAPIClient_SwarmGetUnlockKey_Call) Run(run func(ctx context.Context)) *MockAPIClient_SwarmGetUnlockKey_Call

+ func (_c *MockAPIClient_SwarmGetUnlockKey_Call) RunAndReturn(run func(ctx context.Context) (swarm.UnlockKeyResponse, error)) *MockAPIClient_SwarmGetUnlockKey_Call

+ type MockAPIClient_SwarmInit_Call struct

+ func (_c *MockAPIClient_SwarmInit_Call) Return(s string, err error) *MockAPIClient_SwarmInit_Call

+ func (_c *MockAPIClient_SwarmInit_Call) Run(run func(ctx context.Context, req swarm.InitRequest)) *MockAPIClient_SwarmInit_Call

+ func (_c *MockAPIClient_SwarmInit_Call) RunAndReturn(run func(ctx context.Context, req swarm.InitRequest) (string, error)) *MockAPIClient_SwarmInit_Call

+ type MockAPIClient_SwarmInspect_Call struct

+ func (_c *MockAPIClient_SwarmInspect_Call) Return(swarm1 swarm.Swarm, err error) *MockAPIClient_SwarmInspect_Call

+ func (_c *MockAPIClient_SwarmInspect_Call) Run(run func(ctx context.Context)) *MockAPIClient_SwarmInspect_Call

+ func (_c *MockAPIClient_SwarmInspect_Call) RunAndReturn(run func(ctx context.Context) (swarm.Swarm, error)) *MockAPIClient_SwarmInspect_Call

+ type MockAPIClient_SwarmJoin_Call struct

+ func (_c *MockAPIClient_SwarmJoin_Call) Return(err error) *MockAPIClient_SwarmJoin_Call

+ func (_c *MockAPIClient_SwarmJoin_Call) Run(run func(ctx context.Context, req swarm.JoinRequest)) *MockAPIClient_SwarmJoin_Call

+ func (_c *MockAPIClient_SwarmJoin_Call) RunAndReturn(run func(ctx context.Context, req swarm.JoinRequest) error) *MockAPIClient_SwarmJoin_Call

+ type MockAPIClient_SwarmLeave_Call struct

+ func (_c *MockAPIClient_SwarmLeave_Call) Return(err error) *MockAPIClient_SwarmLeave_Call

+ func (_c *MockAPIClient_SwarmLeave_Call) Run(run func(ctx context.Context, force bool)) *MockAPIClient_SwarmLeave_Call

+ func (_c *MockAPIClient_SwarmLeave_Call) RunAndReturn(run func(ctx context.Context, force bool) error) *MockAPIClient_SwarmLeave_Call

+ type MockAPIClient_SwarmUnlock_Call struct

+ func (_c *MockAPIClient_SwarmUnlock_Call) Return(err error) *MockAPIClient_SwarmUnlock_Call

+ func (_c *MockAPIClient_SwarmUnlock_Call) Run(run func(ctx context.Context, req swarm.UnlockRequest)) *MockAPIClient_SwarmUnlock_Call

+ func (_c *MockAPIClient_SwarmUnlock_Call) RunAndReturn(run func(ctx context.Context, req swarm.UnlockRequest) error) *MockAPIClient_SwarmUnlock_Call

+ type MockAPIClient_SwarmUpdate_Call struct

+ func (_c *MockAPIClient_SwarmUpdate_Call) Return(err error) *MockAPIClient_SwarmUpdate_Call

+ func (_c *MockAPIClient_SwarmUpdate_Call) Run(run func(ctx context.Context, version swarm.Version, swarm1 swarm.Spec, ...)) *MockAPIClient_SwarmUpdate_Call

+ func (_c *MockAPIClient_SwarmUpdate_Call) RunAndReturn(...) *MockAPIClient_SwarmUpdate_Call

+ type MockAPIClient_TaskInspectWithRaw_Call struct

+ func (_c *MockAPIClient_TaskInspectWithRaw_Call) Return(task swarm.Task, bytes []byte, err error) *MockAPIClient_TaskInspectWithRaw_Call

+ func (_c *MockAPIClient_TaskInspectWithRaw_Call) Run(run func(ctx context.Context, taskID string)) *MockAPIClient_TaskInspectWithRaw_Call

+ func (_c *MockAPIClient_TaskInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, taskID string) (swarm.Task, []byte, error)) *MockAPIClient_TaskInspectWithRaw_Call

+ type MockAPIClient_TaskList_Call struct

+ func (_c *MockAPIClient_TaskList_Call) Return(tasks []swarm.Task, err error) *MockAPIClient_TaskList_Call

+ func (_c *MockAPIClient_TaskList_Call) Run(run func(ctx context.Context, options swarm.TaskListOptions)) *MockAPIClient_TaskList_Call

+ func (_c *MockAPIClient_TaskList_Call) RunAndReturn(...) *MockAPIClient_TaskList_Call

+ type MockAPIClient_TaskLogs_Call struct

+ func (_c *MockAPIClient_TaskLogs_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_TaskLogs_Call

+ func (_c *MockAPIClient_TaskLogs_Call) Run(run func(ctx context.Context, taskID string, options container.LogsOptions)) *MockAPIClient_TaskLogs_Call

+ func (_c *MockAPIClient_TaskLogs_Call) RunAndReturn(...) *MockAPIClient_TaskLogs_Call

+ type MockAPIClient_VolumeCreate_Call struct

+ func (_c *MockAPIClient_VolumeCreate_Call) Return(volume1 volume.Volume, err error) *MockAPIClient_VolumeCreate_Call

+ func (_c *MockAPIClient_VolumeCreate_Call) Run(run func(ctx context.Context, options volume.CreateOptions)) *MockAPIClient_VolumeCreate_Call

+ func (_c *MockAPIClient_VolumeCreate_Call) RunAndReturn(...) *MockAPIClient_VolumeCreate_Call

+ type MockAPIClient_VolumeInspectWithRaw_Call struct

+ func (_c *MockAPIClient_VolumeInspectWithRaw_Call) Return(volume1 volume.Volume, bytes []byte, err error) *MockAPIClient_VolumeInspectWithRaw_Call

+ func (_c *MockAPIClient_VolumeInspectWithRaw_Call) Run(run func(ctx context.Context, volumeID string)) *MockAPIClient_VolumeInspectWithRaw_Call

+ func (_c *MockAPIClient_VolumeInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, volumeID string) (volume.Volume, []byte, error)) *MockAPIClient_VolumeInspectWithRaw_Call

+ type MockAPIClient_VolumeInspect_Call struct

+ func (_c *MockAPIClient_VolumeInspect_Call) Return(volume1 volume.Volume, err error) *MockAPIClient_VolumeInspect_Call

+ func (_c *MockAPIClient_VolumeInspect_Call) Run(run func(ctx context.Context, volumeID string)) *MockAPIClient_VolumeInspect_Call

+ func (_c *MockAPIClient_VolumeInspect_Call) RunAndReturn(run func(ctx context.Context, volumeID string) (volume.Volume, error)) *MockAPIClient_VolumeInspect_Call

+ type MockAPIClient_VolumeList_Call struct

+ func (_c *MockAPIClient_VolumeList_Call) Return(listResponse volume.ListResponse, err error) *MockAPIClient_VolumeList_Call

+ func (_c *MockAPIClient_VolumeList_Call) Run(run func(ctx context.Context, options volume.ListOptions)) *MockAPIClient_VolumeList_Call

+ func (_c *MockAPIClient_VolumeList_Call) RunAndReturn(...) *MockAPIClient_VolumeList_Call

+ type MockAPIClient_VolumeRemove_Call struct

+ func (_c *MockAPIClient_VolumeRemove_Call) Return(err error) *MockAPIClient_VolumeRemove_Call

+ func (_c *MockAPIClient_VolumeRemove_Call) Run(run func(ctx context.Context, volumeID string, force bool)) *MockAPIClient_VolumeRemove_Call

+ func (_c *MockAPIClient_VolumeRemove_Call) RunAndReturn(run func(ctx context.Context, volumeID string, force bool) error) *MockAPIClient_VolumeRemove_Call

+ type MockAPIClient_VolumeUpdate_Call struct

+ func (_c *MockAPIClient_VolumeUpdate_Call) Return(err error) *MockAPIClient_VolumeUpdate_Call

+ func (_c *MockAPIClient_VolumeUpdate_Call) Run(run func(ctx context.Context, volumeID string, version swarm.Version, ...)) *MockAPIClient_VolumeUpdate_Call

+ func (_c *MockAPIClient_VolumeUpdate_Call) RunAndReturn(...) *MockAPIClient_VolumeUpdate_Call

+ type MockAPIClient_VolumesPrune_Call struct

+ func (_c *MockAPIClient_VolumesPrune_Call) Return(pruneReport volume.PruneReport, err error) *MockAPIClient_VolumesPrune_Call

+ func (_c *MockAPIClient_VolumesPrune_Call) Run(run func(ctx context.Context, pruneFilter filters.Args)) *MockAPIClient_VolumesPrune_Call

+ func (_c *MockAPIClient_VolumesPrune_Call) RunAndReturn(...) *MockAPIClient_VolumesPrune_Call

+ type MockContainerAPIClient struct

+ func NewMockContainerAPIClient(t interface{ ... }) *MockContainerAPIClient

+ func (_m *MockContainerAPIClient) EXPECT() *MockContainerAPIClient_Expecter

+ func (_mock *MockContainerAPIClient) ContainerAttach(ctx context.Context, container1 string, options container.AttachOptions) (types.HijackedResponse, error)

+ func (_mock *MockContainerAPIClient) ContainerCommit(ctx context.Context, container1 string, options container.CommitOptions) (container.CommitResponse, error)

+ func (_mock *MockContainerAPIClient) ContainerCreate(ctx context.Context, config *container.Config, ...) (container.CreateResponse, error)

+ func (_mock *MockContainerAPIClient) ContainerDiff(ctx context.Context, container1 string) ([]container.FilesystemChange, error)

+ func (_mock *MockContainerAPIClient) ContainerExecAttach(ctx context.Context, execID string, options container.ExecAttachOptions) (types.HijackedResponse, error)

+ func (_mock *MockContainerAPIClient) ContainerExecCreate(ctx context.Context, container1 string, options container.ExecOptions) (container.ExecCreateResponse, error)

+ func (_mock *MockContainerAPIClient) ContainerExecInspect(ctx context.Context, execID string) (container.ExecInspect, error)

+ func (_mock *MockContainerAPIClient) ContainerExecResize(ctx context.Context, execID string, options container.ResizeOptions) error

+ func (_mock *MockContainerAPIClient) ContainerExecStart(ctx context.Context, execID string, options container.ExecStartOptions) error

+ func (_mock *MockContainerAPIClient) ContainerExport(ctx context.Context, container1 string) (io.ReadCloser, error)

+ func (_mock *MockContainerAPIClient) ContainerInspect(ctx context.Context, container1 string) (container.InspectResponse, error)

+ func (_mock *MockContainerAPIClient) ContainerInspectWithRaw(ctx context.Context, container1 string, getSize bool) (container.InspectResponse, []byte, error)

+ func (_mock *MockContainerAPIClient) ContainerKill(ctx context.Context, container1 string, signal string) error

+ func (_mock *MockContainerAPIClient) ContainerList(ctx context.Context, options container.ListOptions) ([]container.Summary, error)

+ func (_mock *MockContainerAPIClient) ContainerLogs(ctx context.Context, container1 string, options container.LogsOptions) (io.ReadCloser, error)

+ func (_mock *MockContainerAPIClient) ContainerPause(ctx context.Context, container1 string) error

+ func (_mock *MockContainerAPIClient) ContainerRemove(ctx context.Context, container1 string, options container.RemoveOptions) error

+ func (_mock *MockContainerAPIClient) ContainerRename(ctx context.Context, container1 string, newContainerName string) error

+ func (_mock *MockContainerAPIClient) ContainerResize(ctx context.Context, container1 string, options container.ResizeOptions) error

+ func (_mock *MockContainerAPIClient) ContainerRestart(ctx context.Context, container1 string, options container.StopOptions) error

+ func (_mock *MockContainerAPIClient) ContainerStart(ctx context.Context, container1 string, options container.StartOptions) error

+ func (_mock *MockContainerAPIClient) ContainerStatPath(ctx context.Context, container1 string, path string) (container.PathStat, error)

+ func (_mock *MockContainerAPIClient) ContainerStats(ctx context.Context, container1 string, stream bool) (container.StatsResponseReader, error)

+ func (_mock *MockContainerAPIClient) ContainerStatsOneShot(ctx context.Context, container1 string) (container.StatsResponseReader, error)

+ func (_mock *MockContainerAPIClient) ContainerStop(ctx context.Context, container1 string, options container.StopOptions) error

+ func (_mock *MockContainerAPIClient) ContainerTop(ctx context.Context, container1 string, arguments []string) (container.TopResponse, error)

+ func (_mock *MockContainerAPIClient) ContainerUnpause(ctx context.Context, container1 string) error

+ func (_mock *MockContainerAPIClient) ContainerUpdate(ctx context.Context, container1 string, updateConfig container.UpdateConfig) (container.UpdateResponse, error)

+ func (_mock *MockContainerAPIClient) ContainerWait(ctx context.Context, container1 string, condition container.WaitCondition) (<-chan container.WaitResponse, <-chan error)

+ func (_mock *MockContainerAPIClient) ContainersPrune(ctx context.Context, pruneFilters filters.Args) (container.PruneReport, error)

+ func (_mock *MockContainerAPIClient) CopyFromContainer(ctx context.Context, container1 string, srcPath string) (io.ReadCloser, container.PathStat, error)

+ func (_mock *MockContainerAPIClient) CopyToContainer(ctx context.Context, container1 string, path string, content io.Reader, ...) error

+ type MockContainerAPIClient_ContainerAttach_Call struct

+ func (_c *MockContainerAPIClient_ContainerAttach_Call) Return(hijackedResponse types.HijackedResponse, err error) *MockContainerAPIClient_ContainerAttach_Call

+ func (_c *MockContainerAPIClient_ContainerAttach_Call) Run(...) *MockContainerAPIClient_ContainerAttach_Call

+ func (_c *MockContainerAPIClient_ContainerAttach_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerAttach_Call

+ type MockContainerAPIClient_ContainerCommit_Call struct

+ func (_c *MockContainerAPIClient_ContainerCommit_Call) Return(v container.CommitResponse, err error) *MockContainerAPIClient_ContainerCommit_Call

+ func (_c *MockContainerAPIClient_ContainerCommit_Call) Run(...) *MockContainerAPIClient_ContainerCommit_Call

+ func (_c *MockContainerAPIClient_ContainerCommit_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerCommit_Call

+ type MockContainerAPIClient_ContainerCreate_Call struct

+ func (_c *MockContainerAPIClient_ContainerCreate_Call) Return(createResponse container.CreateResponse, err error) *MockContainerAPIClient_ContainerCreate_Call

+ func (_c *MockContainerAPIClient_ContainerCreate_Call) Run(run func(ctx context.Context, config *container.Config, ...)) *MockContainerAPIClient_ContainerCreate_Call

+ func (_c *MockContainerAPIClient_ContainerCreate_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerCreate_Call

+ type MockContainerAPIClient_ContainerDiff_Call struct

+ func (_c *MockContainerAPIClient_ContainerDiff_Call) Return(filesystemChanges []container.FilesystemChange, err error) *MockContainerAPIClient_ContainerDiff_Call

+ func (_c *MockContainerAPIClient_ContainerDiff_Call) Run(run func(ctx context.Context, container1 string)) *MockContainerAPIClient_ContainerDiff_Call

+ func (_c *MockContainerAPIClient_ContainerDiff_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerDiff_Call

+ type MockContainerAPIClient_ContainerExecAttach_Call struct

+ func (_c *MockContainerAPIClient_ContainerExecAttach_Call) Return(hijackedResponse types.HijackedResponse, err error) *MockContainerAPIClient_ContainerExecAttach_Call

+ func (_c *MockContainerAPIClient_ContainerExecAttach_Call) Run(...) *MockContainerAPIClient_ContainerExecAttach_Call

+ func (_c *MockContainerAPIClient_ContainerExecAttach_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerExecAttach_Call

+ type MockContainerAPIClient_ContainerExecCreate_Call struct

+ func (_c *MockContainerAPIClient_ContainerExecCreate_Call) Return(v container.ExecCreateResponse, err error) *MockContainerAPIClient_ContainerExecCreate_Call

+ func (_c *MockContainerAPIClient_ContainerExecCreate_Call) Run(...) *MockContainerAPIClient_ContainerExecCreate_Call

+ func (_c *MockContainerAPIClient_ContainerExecCreate_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerExecCreate_Call

+ type MockContainerAPIClient_ContainerExecInspect_Call struct

+ func (_c *MockContainerAPIClient_ContainerExecInspect_Call) Return(execInspect container.ExecInspect, err error) *MockContainerAPIClient_ContainerExecInspect_Call

+ func (_c *MockContainerAPIClient_ContainerExecInspect_Call) Run(run func(ctx context.Context, execID string)) *MockContainerAPIClient_ContainerExecInspect_Call

+ func (_c *MockContainerAPIClient_ContainerExecInspect_Call) RunAndReturn(run func(ctx context.Context, execID string) (container.ExecInspect, error)) *MockContainerAPIClient_ContainerExecInspect_Call

+ type MockContainerAPIClient_ContainerExecResize_Call struct

+ func (_c *MockContainerAPIClient_ContainerExecResize_Call) Return(err error) *MockContainerAPIClient_ContainerExecResize_Call

+ func (_c *MockContainerAPIClient_ContainerExecResize_Call) Run(run func(ctx context.Context, execID string, options container.ResizeOptions)) *MockContainerAPIClient_ContainerExecResize_Call

+ func (_c *MockContainerAPIClient_ContainerExecResize_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerExecResize_Call

+ type MockContainerAPIClient_ContainerExecStart_Call struct

+ func (_c *MockContainerAPIClient_ContainerExecStart_Call) Return(err error) *MockContainerAPIClient_ContainerExecStart_Call

+ func (_c *MockContainerAPIClient_ContainerExecStart_Call) Run(...) *MockContainerAPIClient_ContainerExecStart_Call

+ func (_c *MockContainerAPIClient_ContainerExecStart_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerExecStart_Call

+ type MockContainerAPIClient_ContainerExport_Call struct

+ func (_c *MockContainerAPIClient_ContainerExport_Call) Return(readCloser io.ReadCloser, err error) *MockContainerAPIClient_ContainerExport_Call

+ func (_c *MockContainerAPIClient_ContainerExport_Call) Run(run func(ctx context.Context, container1 string)) *MockContainerAPIClient_ContainerExport_Call

+ func (_c *MockContainerAPIClient_ContainerExport_Call) RunAndReturn(run func(ctx context.Context, container1 string) (io.ReadCloser, error)) *MockContainerAPIClient_ContainerExport_Call

+ type MockContainerAPIClient_ContainerInspectWithRaw_Call struct

+ func (_c *MockContainerAPIClient_ContainerInspectWithRaw_Call) Return(inspectResponse container.InspectResponse, bytes []byte, err error) *MockContainerAPIClient_ContainerInspectWithRaw_Call

+ func (_c *MockContainerAPIClient_ContainerInspectWithRaw_Call) Run(run func(ctx context.Context, container1 string, getSize bool)) *MockContainerAPIClient_ContainerInspectWithRaw_Call

+ func (_c *MockContainerAPIClient_ContainerInspectWithRaw_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerInspectWithRaw_Call

+ type MockContainerAPIClient_ContainerInspect_Call struct

+ func (_c *MockContainerAPIClient_ContainerInspect_Call) Return(inspectResponse container.InspectResponse, err error) *MockContainerAPIClient_ContainerInspect_Call

+ func (_c *MockContainerAPIClient_ContainerInspect_Call) Run(run func(ctx context.Context, container1 string)) *MockContainerAPIClient_ContainerInspect_Call

+ func (_c *MockContainerAPIClient_ContainerInspect_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerInspect_Call

+ type MockContainerAPIClient_ContainerKill_Call struct

+ func (_c *MockContainerAPIClient_ContainerKill_Call) Return(err error) *MockContainerAPIClient_ContainerKill_Call

+ func (_c *MockContainerAPIClient_ContainerKill_Call) Run(run func(ctx context.Context, container1 string, signal string)) *MockContainerAPIClient_ContainerKill_Call

+ func (_c *MockContainerAPIClient_ContainerKill_Call) RunAndReturn(run func(ctx context.Context, container1 string, signal string) error) *MockContainerAPIClient_ContainerKill_Call

+ type MockContainerAPIClient_ContainerList_Call struct

+ func (_c *MockContainerAPIClient_ContainerList_Call) Return(summarys []container.Summary, err error) *MockContainerAPIClient_ContainerList_Call

+ func (_c *MockContainerAPIClient_ContainerList_Call) Run(run func(ctx context.Context, options container.ListOptions)) *MockContainerAPIClient_ContainerList_Call

+ func (_c *MockContainerAPIClient_ContainerList_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerList_Call

+ type MockContainerAPIClient_ContainerLogs_Call struct

+ func (_c *MockContainerAPIClient_ContainerLogs_Call) Return(readCloser io.ReadCloser, err error) *MockContainerAPIClient_ContainerLogs_Call

+ func (_c *MockContainerAPIClient_ContainerLogs_Call) Run(...) *MockContainerAPIClient_ContainerLogs_Call

+ func (_c *MockContainerAPIClient_ContainerLogs_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerLogs_Call

+ type MockContainerAPIClient_ContainerPause_Call struct

+ func (_c *MockContainerAPIClient_ContainerPause_Call) Return(err error) *MockContainerAPIClient_ContainerPause_Call

+ func (_c *MockContainerAPIClient_ContainerPause_Call) Run(run func(ctx context.Context, container1 string)) *MockContainerAPIClient_ContainerPause_Call

+ func (_c *MockContainerAPIClient_ContainerPause_Call) RunAndReturn(run func(ctx context.Context, container1 string) error) *MockContainerAPIClient_ContainerPause_Call

+ type MockContainerAPIClient_ContainerRemove_Call struct

+ func (_c *MockContainerAPIClient_ContainerRemove_Call) Return(err error) *MockContainerAPIClient_ContainerRemove_Call

+ func (_c *MockContainerAPIClient_ContainerRemove_Call) Run(...) *MockContainerAPIClient_ContainerRemove_Call

+ func (_c *MockContainerAPIClient_ContainerRemove_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerRemove_Call

+ type MockContainerAPIClient_ContainerRename_Call struct

+ func (_c *MockContainerAPIClient_ContainerRename_Call) Return(err error) *MockContainerAPIClient_ContainerRename_Call

+ func (_c *MockContainerAPIClient_ContainerRename_Call) Run(run func(ctx context.Context, container1 string, newContainerName string)) *MockContainerAPIClient_ContainerRename_Call

+ func (_c *MockContainerAPIClient_ContainerRename_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerRename_Call

+ type MockContainerAPIClient_ContainerResize_Call struct

+ func (_c *MockContainerAPIClient_ContainerResize_Call) Return(err error) *MockContainerAPIClient_ContainerResize_Call

+ func (_c *MockContainerAPIClient_ContainerResize_Call) Run(...) *MockContainerAPIClient_ContainerResize_Call

+ func (_c *MockContainerAPIClient_ContainerResize_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerResize_Call

+ type MockContainerAPIClient_ContainerRestart_Call struct

+ func (_c *MockContainerAPIClient_ContainerRestart_Call) Return(err error) *MockContainerAPIClient_ContainerRestart_Call

+ func (_c *MockContainerAPIClient_ContainerRestart_Call) Run(...) *MockContainerAPIClient_ContainerRestart_Call

+ func (_c *MockContainerAPIClient_ContainerRestart_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerRestart_Call

+ type MockContainerAPIClient_ContainerStart_Call struct

+ func (_c *MockContainerAPIClient_ContainerStart_Call) Return(err error) *MockContainerAPIClient_ContainerStart_Call

+ func (_c *MockContainerAPIClient_ContainerStart_Call) Run(...) *MockContainerAPIClient_ContainerStart_Call

+ func (_c *MockContainerAPIClient_ContainerStart_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerStart_Call

+ type MockContainerAPIClient_ContainerStatPath_Call struct

+ func (_c *MockContainerAPIClient_ContainerStatPath_Call) Return(pathStat container.PathStat, err error) *MockContainerAPIClient_ContainerStatPath_Call

+ func (_c *MockContainerAPIClient_ContainerStatPath_Call) Run(run func(ctx context.Context, container1 string, path string)) *MockContainerAPIClient_ContainerStatPath_Call

+ func (_c *MockContainerAPIClient_ContainerStatPath_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerStatPath_Call

+ type MockContainerAPIClient_ContainerStatsOneShot_Call struct

+ func (_c *MockContainerAPIClient_ContainerStatsOneShot_Call) Return(statsResponseReader container.StatsResponseReader, err error) *MockContainerAPIClient_ContainerStatsOneShot_Call

+ func (_c *MockContainerAPIClient_ContainerStatsOneShot_Call) Run(run func(ctx context.Context, container1 string)) *MockContainerAPIClient_ContainerStatsOneShot_Call

+ func (_c *MockContainerAPIClient_ContainerStatsOneShot_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerStatsOneShot_Call

+ type MockContainerAPIClient_ContainerStats_Call struct

+ func (_c *MockContainerAPIClient_ContainerStats_Call) Return(statsResponseReader container.StatsResponseReader, err error) *MockContainerAPIClient_ContainerStats_Call

+ func (_c *MockContainerAPIClient_ContainerStats_Call) Run(run func(ctx context.Context, container1 string, stream bool)) *MockContainerAPIClient_ContainerStats_Call

+ func (_c *MockContainerAPIClient_ContainerStats_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerStats_Call

+ type MockContainerAPIClient_ContainerStop_Call struct

+ func (_c *MockContainerAPIClient_ContainerStop_Call) Return(err error) *MockContainerAPIClient_ContainerStop_Call

+ func (_c *MockContainerAPIClient_ContainerStop_Call) Run(...) *MockContainerAPIClient_ContainerStop_Call

+ func (_c *MockContainerAPIClient_ContainerStop_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerStop_Call

+ type MockContainerAPIClient_ContainerTop_Call struct

+ func (_c *MockContainerAPIClient_ContainerTop_Call) Return(topResponse container.TopResponse, err error) *MockContainerAPIClient_ContainerTop_Call

+ func (_c *MockContainerAPIClient_ContainerTop_Call) Run(run func(ctx context.Context, container1 string, arguments []string)) *MockContainerAPIClient_ContainerTop_Call

+ func (_c *MockContainerAPIClient_ContainerTop_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerTop_Call

+ type MockContainerAPIClient_ContainerUnpause_Call struct

+ func (_c *MockContainerAPIClient_ContainerUnpause_Call) Return(err error) *MockContainerAPIClient_ContainerUnpause_Call

+ func (_c *MockContainerAPIClient_ContainerUnpause_Call) Run(run func(ctx context.Context, container1 string)) *MockContainerAPIClient_ContainerUnpause_Call

+ func (_c *MockContainerAPIClient_ContainerUnpause_Call) RunAndReturn(run func(ctx context.Context, container1 string) error) *MockContainerAPIClient_ContainerUnpause_Call

+ type MockContainerAPIClient_ContainerUpdate_Call struct

+ func (_c *MockContainerAPIClient_ContainerUpdate_Call) Return(updateResponse container.UpdateResponse, err error) *MockContainerAPIClient_ContainerUpdate_Call

+ func (_c *MockContainerAPIClient_ContainerUpdate_Call) Run(...) *MockContainerAPIClient_ContainerUpdate_Call

+ func (_c *MockContainerAPIClient_ContainerUpdate_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerUpdate_Call

+ type MockContainerAPIClient_ContainerWait_Call struct

+ func (_c *MockContainerAPIClient_ContainerWait_Call) Return(waitResponseCh <-chan container.WaitResponse, errCh <-chan error) *MockContainerAPIClient_ContainerWait_Call

+ func (_c *MockContainerAPIClient_ContainerWait_Call) Run(...) *MockContainerAPIClient_ContainerWait_Call

+ func (_c *MockContainerAPIClient_ContainerWait_Call) RunAndReturn(...) *MockContainerAPIClient_ContainerWait_Call

+ type MockContainerAPIClient_ContainersPrune_Call struct

+ func (_c *MockContainerAPIClient_ContainersPrune_Call) Return(pruneReport container.PruneReport, err error) *MockContainerAPIClient_ContainersPrune_Call

+ func (_c *MockContainerAPIClient_ContainersPrune_Call) Run(run func(ctx context.Context, pruneFilters filters.Args)) *MockContainerAPIClient_ContainersPrune_Call

+ func (_c *MockContainerAPIClient_ContainersPrune_Call) RunAndReturn(...) *MockContainerAPIClient_ContainersPrune_Call

+ type MockContainerAPIClient_CopyFromContainer_Call struct

+ func (_c *MockContainerAPIClient_CopyFromContainer_Call) Return(readCloser io.ReadCloser, pathStat container.PathStat, err error) *MockContainerAPIClient_CopyFromContainer_Call

+ func (_c *MockContainerAPIClient_CopyFromContainer_Call) Run(run func(ctx context.Context, container1 string, srcPath string)) *MockContainerAPIClient_CopyFromContainer_Call

+ func (_c *MockContainerAPIClient_CopyFromContainer_Call) RunAndReturn(...) *MockContainerAPIClient_CopyFromContainer_Call

+ type MockContainerAPIClient_CopyToContainer_Call struct

+ func (_c *MockContainerAPIClient_CopyToContainer_Call) Return(err error) *MockContainerAPIClient_CopyToContainer_Call

+ func (_c *MockContainerAPIClient_CopyToContainer_Call) Run(...) *MockContainerAPIClient_CopyToContainer_Call

+ func (_c *MockContainerAPIClient_CopyToContainer_Call) RunAndReturn(...) *MockContainerAPIClient_CopyToContainer_Call

+ type MockContainerAPIClient_Expecter struct

+ func (_e *MockContainerAPIClient_Expecter) ContainerAttach(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerAttach_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerCommit(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerCommit_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerCreate(ctx interface{}, config interface{}, hostConfig interface{}, ...) *MockContainerAPIClient_ContainerCreate_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerDiff(ctx interface{}, container1 interface{}) *MockContainerAPIClient_ContainerDiff_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerExecAttach(ctx interface{}, execID interface{}, options interface{}) *MockContainerAPIClient_ContainerExecAttach_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerExecCreate(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerExecCreate_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerExecInspect(ctx interface{}, execID interface{}) *MockContainerAPIClient_ContainerExecInspect_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerExecResize(ctx interface{}, execID interface{}, options interface{}) *MockContainerAPIClient_ContainerExecResize_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerExecStart(ctx interface{}, execID interface{}, options interface{}) *MockContainerAPIClient_ContainerExecStart_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerExport(ctx interface{}, container1 interface{}) *MockContainerAPIClient_ContainerExport_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerInspect(ctx interface{}, container1 interface{}) *MockContainerAPIClient_ContainerInspect_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerInspectWithRaw(ctx interface{}, container1 interface{}, getSize interface{}) *MockContainerAPIClient_ContainerInspectWithRaw_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerKill(ctx interface{}, container1 interface{}, signal interface{}) *MockContainerAPIClient_ContainerKill_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerList(ctx interface{}, options interface{}) *MockContainerAPIClient_ContainerList_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerLogs(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerLogs_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerPause(ctx interface{}, container1 interface{}) *MockContainerAPIClient_ContainerPause_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerRemove(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerRemove_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerRename(ctx interface{}, container1 interface{}, newContainerName interface{}) *MockContainerAPIClient_ContainerRename_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerResize(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerResize_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerRestart(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerRestart_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerStart(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerStart_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerStatPath(ctx interface{}, container1 interface{}, path interface{}) *MockContainerAPIClient_ContainerStatPath_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerStats(ctx interface{}, container1 interface{}, stream interface{}) *MockContainerAPIClient_ContainerStats_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerStatsOneShot(ctx interface{}, container1 interface{}) *MockContainerAPIClient_ContainerStatsOneShot_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerStop(ctx interface{}, container1 interface{}, options interface{}) *MockContainerAPIClient_ContainerStop_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerTop(ctx interface{}, container1 interface{}, arguments interface{}) *MockContainerAPIClient_ContainerTop_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerUnpause(ctx interface{}, container1 interface{}) *MockContainerAPIClient_ContainerUnpause_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerUpdate(ctx interface{}, container1 interface{}, updateConfig interface{}) *MockContainerAPIClient_ContainerUpdate_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainerWait(ctx interface{}, container1 interface{}, condition interface{}) *MockContainerAPIClient_ContainerWait_Call

+ func (_e *MockContainerAPIClient_Expecter) ContainersPrune(ctx interface{}, pruneFilters interface{}) *MockContainerAPIClient_ContainersPrune_Call

+ func (_e *MockContainerAPIClient_Expecter) CopyFromContainer(ctx interface{}, container1 interface{}, srcPath interface{}) *MockContainerAPIClient_CopyFromContainer_Call

+ func (_e *MockContainerAPIClient_Expecter) CopyToContainer(ctx interface{}, container1 interface{}, path interface{}, content interface{}, ...) *MockContainerAPIClient_CopyToContainer_Call