[lxc-devel] [lxd/master] Lxd client mocking
wupeka on Github
lxc-bot at linuxcontainers.org
Wed Mar 21 08:44:41 UTC 2018
A non-text attachment was scrubbed...
Name: not available
Type: text/x-mailbox
Size: 588 bytes
Desc: not available
URL: <http://lists.linuxcontainers.org/pipermail/lxc-devel/attachments/20180321/5493b867/attachment.bin>
-------------- next part --------------
From dee99047cf5715261ba3db99c619206e1ae2484b Mon Sep 17 00:00:00 2001
From: Witold Krecicki <wpk at culm.net>
Date: Wed, 21 Mar 2018 09:31:08 +0100
Subject: [PATCH 1/2] Add NewOperation and NewRemoteOperation in client library
Signed-off-by: Witold Krecicki <witold.krecicki at canonical.com>
---
client/operations.go | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/client/operations.go b/client/operations.go
index 90544ff96..e8ed9b79d 100644
--- a/client/operations.go
+++ b/client/operations.go
@@ -22,6 +22,11 @@ type Operation struct {
chActive chan bool
}
+// NewOperation creates an operation from provided parameters, used for mocking.
+func NewOperation(op api.Operation, r *ProtocolLXD, listener *EventListener, handlerReady bool, handlerLock sync.Mutex, chActive chan bool) (Operation) {
+ return Operation{op, r, listener, handlerReady, handlerLock, chActive}
+}
+
// AddHandler adds a function to be called whenever an event is received
func (op *Operation) AddHandler(function func(api.Operation)) (*EventTarget, error) {
// Make sure we have a listener setup
@@ -283,6 +288,11 @@ type RemoteOperation struct {
err error
}
+// NewRemoteOperation creates a remote operation from provided parameters, used for mocking.
+func NewRemoteOperation(targetOp *Operation, handlers []func(api.Operation), chDone, chPost chan bool, err error) (RemoteOperation) {
+ return RemoteOperation{targetOp, handlers, chDone, chPost, err}
+}
+
// AddHandler adds a function to be called whenever an event is received
func (op *RemoteOperation) AddHandler(function func(api.Operation)) (*EventTarget, error) {
var err error
From 77cdffff977d228ee73228b8b66594dcd47bf915 Mon Sep 17 00:00:00 2001
From: Witold Krecicki <wpk at culm.net>
Date: Wed, 21 Mar 2018 09:37:42 +0100
Subject: [PATCH 2/2] Add mock lxd client interface.
Signed-off-by: Witold Krecicki <witold.krecicki at canonical.com>
---
client/mock_test.go | 10 +
client/mocks/Makefile | 2 +
client/mocks/mock_lxd.go | 1794 ++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 1806 insertions(+)
create mode 100644 client/mock_test.go
create mode 100644 client/mocks/Makefile
create mode 100644 client/mocks/mock_lxd.go
diff --git a/client/mock_test.go b/client/mock_test.go
new file mode 100644
index 000000000..548d3b1db
--- /dev/null
+++ b/client/mock_test.go
@@ -0,0 +1,10 @@
+package lxd_test
+
+import (
+ "github.com/lxc/lxd/client"
+ "github.com/lxc/lxd/client/mocks"
+)
+
+var _ lxd.Server = (*mocks.MockServer)(nil)
+var _ lxd.ImageServer = (*mocks.MockImageServer)(nil)
+var _ lxd.ContainerServer = (*mocks.MockContainerServer)(nil)
diff --git a/client/mocks/Makefile b/client/mocks/Makefile
new file mode 100644
index 000000000..0c1ed5dfc
--- /dev/null
+++ b/client/mocks/Makefile
@@ -0,0 +1,2 @@
+mock:
+ mockgen -destination=./mock_lxd.go -package=mocks github.com/lxc/lxd/client Server,ImageServer,ContainerServer
diff --git a/client/mocks/mock_lxd.go b/client/mocks/mock_lxd.go
new file mode 100644
index 000000000..8626f61fd
--- /dev/null
+++ b/client/mocks/mock_lxd.go
@@ -0,0 +1,1794 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/lxc/lxd/client (interfaces: Server,ImageServer,ContainerServer)
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+ gomock "github.com/golang/mock/gomock"
+ websocket "github.com/gorilla/websocket"
+ client "github.com/lxc/lxd/client"
+ api "github.com/lxc/lxd/shared/api"
+ io "io"
+ http "net/http"
+ reflect "reflect"
+)
+
+// MockServer is a mock of Server interface
+type MockServer struct {
+ ctrl *gomock.Controller
+ recorder *MockServerMockRecorder
+}
+
+// MockServerMockRecorder is the mock recorder for MockServer
+type MockServerMockRecorder struct {
+ mock *MockServer
+}
+
+// NewMockServer creates a new mock instance
+func NewMockServer(ctrl *gomock.Controller) *MockServer {
+ mock := &MockServer{ctrl: ctrl}
+ mock.recorder = &MockServerMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockServer) EXPECT() *MockServerMockRecorder {
+ return m.recorder
+}
+
+// GetConnectionInfo mocks base method
+func (m *MockServer) GetConnectionInfo() (*client.ConnectionInfo, error) {
+ ret := m.ctrl.Call(m, "GetConnectionInfo")
+ ret0, _ := ret[0].(*client.ConnectionInfo)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetConnectionInfo indicates an expected call of GetConnectionInfo
+func (mr *MockServerMockRecorder) GetConnectionInfo() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionInfo", reflect.TypeOf((*MockServer)(nil).GetConnectionInfo))
+}
+
+// GetHTTPClient mocks base method
+func (m *MockServer) GetHTTPClient() (*http.Client, error) {
+ ret := m.ctrl.Call(m, "GetHTTPClient")
+ ret0, _ := ret[0].(*http.Client)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetHTTPClient indicates an expected call of GetHTTPClient
+func (mr *MockServerMockRecorder) GetHTTPClient() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHTTPClient", reflect.TypeOf((*MockServer)(nil).GetHTTPClient))
+}
+
+// MockImageServer is a mock of ImageServer interface
+type MockImageServer struct {
+ ctrl *gomock.Controller
+ recorder *MockImageServerMockRecorder
+}
+
+// MockImageServerMockRecorder is the mock recorder for MockImageServer
+type MockImageServerMockRecorder struct {
+ mock *MockImageServer
+}
+
+// NewMockImageServer creates a new mock instance
+func NewMockImageServer(ctrl *gomock.Controller) *MockImageServer {
+ mock := &MockImageServer{ctrl: ctrl}
+ mock.recorder = &MockImageServerMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockImageServer) EXPECT() *MockImageServerMockRecorder {
+ return m.recorder
+}
+
+// GetConnectionInfo mocks base method
+func (m *MockImageServer) GetConnectionInfo() (*client.ConnectionInfo, error) {
+ ret := m.ctrl.Call(m, "GetConnectionInfo")
+ ret0, _ := ret[0].(*client.ConnectionInfo)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetConnectionInfo indicates an expected call of GetConnectionInfo
+func (mr *MockImageServerMockRecorder) GetConnectionInfo() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionInfo", reflect.TypeOf((*MockImageServer)(nil).GetConnectionInfo))
+}
+
+// GetHTTPClient mocks base method
+func (m *MockImageServer) GetHTTPClient() (*http.Client, error) {
+ ret := m.ctrl.Call(m, "GetHTTPClient")
+ ret0, _ := ret[0].(*http.Client)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetHTTPClient indicates an expected call of GetHTTPClient
+func (mr *MockImageServerMockRecorder) GetHTTPClient() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHTTPClient", reflect.TypeOf((*MockImageServer)(nil).GetHTTPClient))
+}
+
+// GetImage mocks base method
+func (m *MockImageServer) GetImage(arg0 string) (*api.Image, string, error) {
+ ret := m.ctrl.Call(m, "GetImage", arg0)
+ ret0, _ := ret[0].(*api.Image)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetImage indicates an expected call of GetImage
+func (mr *MockImageServerMockRecorder) GetImage(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImage", reflect.TypeOf((*MockImageServer)(nil).GetImage), arg0)
+}
+
+// GetImageAlias mocks base method
+func (m *MockImageServer) GetImageAlias(arg0 string) (*api.ImageAliasesEntry, string, error) {
+ ret := m.ctrl.Call(m, "GetImageAlias", arg0)
+ ret0, _ := ret[0].(*api.ImageAliasesEntry)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetImageAlias indicates an expected call of GetImageAlias
+func (mr *MockImageServerMockRecorder) GetImageAlias(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAlias", reflect.TypeOf((*MockImageServer)(nil).GetImageAlias), arg0)
+}
+
+// GetImageAliasNames mocks base method
+func (m *MockImageServer) GetImageAliasNames() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetImageAliasNames")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageAliasNames indicates an expected call of GetImageAliasNames
+func (mr *MockImageServerMockRecorder) GetImageAliasNames() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAliasNames", reflect.TypeOf((*MockImageServer)(nil).GetImageAliasNames))
+}
+
+// GetImageAliases mocks base method
+func (m *MockImageServer) GetImageAliases() ([]api.ImageAliasesEntry, error) {
+ ret := m.ctrl.Call(m, "GetImageAliases")
+ ret0, _ := ret[0].([]api.ImageAliasesEntry)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageAliases indicates an expected call of GetImageAliases
+func (mr *MockImageServerMockRecorder) GetImageAliases() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAliases", reflect.TypeOf((*MockImageServer)(nil).GetImageAliases))
+}
+
+// GetImageFile mocks base method
+func (m *MockImageServer) GetImageFile(arg0 string, arg1 client.ImageFileRequest) (*client.ImageFileResponse, error) {
+ ret := m.ctrl.Call(m, "GetImageFile", arg0, arg1)
+ ret0, _ := ret[0].(*client.ImageFileResponse)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageFile indicates an expected call of GetImageFile
+func (mr *MockImageServerMockRecorder) GetImageFile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageFile", reflect.TypeOf((*MockImageServer)(nil).GetImageFile), arg0, arg1)
+}
+
+// GetImageFingerprints mocks base method
+func (m *MockImageServer) GetImageFingerprints() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetImageFingerprints")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageFingerprints indicates an expected call of GetImageFingerprints
+func (mr *MockImageServerMockRecorder) GetImageFingerprints() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageFingerprints", reflect.TypeOf((*MockImageServer)(nil).GetImageFingerprints))
+}
+
+// GetImageSecret mocks base method
+func (m *MockImageServer) GetImageSecret(arg0 string) (string, error) {
+ ret := m.ctrl.Call(m, "GetImageSecret", arg0)
+ ret0, _ := ret[0].(string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageSecret indicates an expected call of GetImageSecret
+func (mr *MockImageServerMockRecorder) GetImageSecret(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageSecret", reflect.TypeOf((*MockImageServer)(nil).GetImageSecret), arg0)
+}
+
+// GetImages mocks base method
+func (m *MockImageServer) GetImages() ([]api.Image, error) {
+ ret := m.ctrl.Call(m, "GetImages")
+ ret0, _ := ret[0].([]api.Image)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImages indicates an expected call of GetImages
+func (mr *MockImageServerMockRecorder) GetImages() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImages", reflect.TypeOf((*MockImageServer)(nil).GetImages))
+}
+
+// GetPrivateImage mocks base method
+func (m *MockImageServer) GetPrivateImage(arg0, arg1 string) (*api.Image, string, error) {
+ ret := m.ctrl.Call(m, "GetPrivateImage", arg0, arg1)
+ ret0, _ := ret[0].(*api.Image)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetPrivateImage indicates an expected call of GetPrivateImage
+func (mr *MockImageServerMockRecorder) GetPrivateImage(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateImage", reflect.TypeOf((*MockImageServer)(nil).GetPrivateImage), arg0, arg1)
+}
+
+// GetPrivateImageFile mocks base method
+func (m *MockImageServer) GetPrivateImageFile(arg0, arg1 string, arg2 client.ImageFileRequest) (*client.ImageFileResponse, error) {
+ ret := m.ctrl.Call(m, "GetPrivateImageFile", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.ImageFileResponse)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetPrivateImageFile indicates an expected call of GetPrivateImageFile
+func (mr *MockImageServerMockRecorder) GetPrivateImageFile(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateImageFile", reflect.TypeOf((*MockImageServer)(nil).GetPrivateImageFile), arg0, arg1, arg2)
+}
+
+// MockContainerServer is a mock of ContainerServer interface
+type MockContainerServer struct {
+ ctrl *gomock.Controller
+ recorder *MockContainerServerMockRecorder
+}
+
+// MockContainerServerMockRecorder is the mock recorder for MockContainerServer
+type MockContainerServerMockRecorder struct {
+ mock *MockContainerServer
+}
+
+// NewMockContainerServer creates a new mock instance
+func NewMockContainerServer(ctrl *gomock.Controller) *MockContainerServer {
+ mock := &MockContainerServer{ctrl: ctrl}
+ mock.recorder = &MockContainerServerMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockContainerServer) EXPECT() *MockContainerServerMockRecorder {
+ return m.recorder
+}
+
+// ConsoleContainer mocks base method
+func (m *MockContainerServer) ConsoleContainer(arg0 string, arg1 api.ContainerConsolePost, arg2 *client.ContainerConsoleArgs) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "ConsoleContainer", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// ConsoleContainer indicates an expected call of ConsoleContainer
+func (mr *MockContainerServerMockRecorder) ConsoleContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsoleContainer", reflect.TypeOf((*MockContainerServer)(nil).ConsoleContainer), arg0, arg1, arg2)
+}
+
+// CopyContainer mocks base method
+func (m *MockContainerServer) CopyContainer(arg0 client.ContainerServer, arg1 api.Container, arg2 *client.ContainerCopyArgs) (*client.RemoteOperation, error) {
+ ret := m.ctrl.Call(m, "CopyContainer", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.RemoteOperation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CopyContainer indicates an expected call of CopyContainer
+func (mr *MockContainerServerMockRecorder) CopyContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyContainer", reflect.TypeOf((*MockContainerServer)(nil).CopyContainer), arg0, arg1, arg2)
+}
+
+// CopyContainerSnapshot mocks base method
+func (m *MockContainerServer) CopyContainerSnapshot(arg0 client.ContainerServer, arg1 api.ContainerSnapshot, arg2 *client.ContainerSnapshotCopyArgs) (*client.RemoteOperation, error) {
+ ret := m.ctrl.Call(m, "CopyContainerSnapshot", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.RemoteOperation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CopyContainerSnapshot indicates an expected call of CopyContainerSnapshot
+func (mr *MockContainerServerMockRecorder) CopyContainerSnapshot(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).CopyContainerSnapshot), arg0, arg1, arg2)
+}
+
+// CopyImage mocks base method
+func (m *MockContainerServer) CopyImage(arg0 client.ImageServer, arg1 api.Image, arg2 *client.ImageCopyArgs) (*client.RemoteOperation, error) {
+ ret := m.ctrl.Call(m, "CopyImage", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.RemoteOperation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CopyImage indicates an expected call of CopyImage
+func (mr *MockContainerServerMockRecorder) CopyImage(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImage", reflect.TypeOf((*MockContainerServer)(nil).CopyImage), arg0, arg1, arg2)
+}
+
+// CopyStoragePoolVolume mocks base method
+func (m *MockContainerServer) CopyStoragePoolVolume(arg0 string, arg1 client.ContainerServer, arg2 string, arg3 api.StorageVolume, arg4 *client.StoragePoolVolumeCopyArgs) (*client.RemoteOperation, error) {
+ ret := m.ctrl.Call(m, "CopyStoragePoolVolume", arg0, arg1, arg2, arg3, arg4)
+ ret0, _ := ret[0].(*client.RemoteOperation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CopyStoragePoolVolume indicates an expected call of CopyStoragePoolVolume
+func (mr *MockContainerServerMockRecorder) CopyStoragePoolVolume(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).CopyStoragePoolVolume), arg0, arg1, arg2, arg3, arg4)
+}
+
+// CreateCertificate mocks base method
+func (m *MockContainerServer) CreateCertificate(arg0 api.CertificatesPost) error {
+ ret := m.ctrl.Call(m, "CreateCertificate", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// CreateCertificate indicates an expected call of CreateCertificate
+func (mr *MockContainerServerMockRecorder) CreateCertificate(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCertificate", reflect.TypeOf((*MockContainerServer)(nil).CreateCertificate), arg0)
+}
+
+// CreateContainer mocks base method
+func (m *MockContainerServer) CreateContainer(arg0 api.ContainersPost) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "CreateContainer", arg0)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CreateContainer indicates an expected call of CreateContainer
+func (mr *MockContainerServerMockRecorder) CreateContainer(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockContainerServer)(nil).CreateContainer), arg0)
+}
+
+// CreateContainerFile mocks base method
+func (m *MockContainerServer) CreateContainerFile(arg0, arg1 string, arg2 client.ContainerFileArgs) error {
+ ret := m.ctrl.Call(m, "CreateContainerFile", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// CreateContainerFile indicates an expected call of CreateContainerFile
+func (mr *MockContainerServerMockRecorder) CreateContainerFile(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerFile", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerFile), arg0, arg1, arg2)
+}
+
+// CreateContainerFromImage mocks base method
+func (m *MockContainerServer) CreateContainerFromImage(arg0 client.ImageServer, arg1 api.Image, arg2 api.ContainersPost) (*client.RemoteOperation, error) {
+ ret := m.ctrl.Call(m, "CreateContainerFromImage", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.RemoteOperation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CreateContainerFromImage indicates an expected call of CreateContainerFromImage
+func (mr *MockContainerServerMockRecorder) CreateContainerFromImage(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerFromImage", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerFromImage), arg0, arg1, arg2)
+}
+
+// CreateContainerSnapshot mocks base method
+func (m *MockContainerServer) CreateContainerSnapshot(arg0 string, arg1 api.ContainerSnapshotsPost) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "CreateContainerSnapshot", arg0, arg1)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CreateContainerSnapshot indicates an expected call of CreateContainerSnapshot
+func (mr *MockContainerServerMockRecorder) CreateContainerSnapshot(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerSnapshot), arg0, arg1)
+}
+
+// CreateContainerTemplateFile mocks base method
+func (m *MockContainerServer) CreateContainerTemplateFile(arg0, arg1 string, arg2 io.ReadSeeker) error {
+ ret := m.ctrl.Call(m, "CreateContainerTemplateFile", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// CreateContainerTemplateFile indicates an expected call of CreateContainerTemplateFile
+func (mr *MockContainerServerMockRecorder) CreateContainerTemplateFile(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerTemplateFile", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerTemplateFile), arg0, arg1, arg2)
+}
+
+// CreateImage mocks base method
+func (m *MockContainerServer) CreateImage(arg0 api.ImagesPost, arg1 *client.ImageCreateArgs) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "CreateImage", arg0, arg1)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CreateImage indicates an expected call of CreateImage
+func (mr *MockContainerServerMockRecorder) CreateImage(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockContainerServer)(nil).CreateImage), arg0, arg1)
+}
+
+// CreateImageAlias mocks base method
+func (m *MockContainerServer) CreateImageAlias(arg0 api.ImageAliasesPost) error {
+ ret := m.ctrl.Call(m, "CreateImageAlias", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// CreateImageAlias indicates an expected call of CreateImageAlias
+func (mr *MockContainerServerMockRecorder) CreateImageAlias(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageAlias", reflect.TypeOf((*MockContainerServer)(nil).CreateImageAlias), arg0)
+}
+
+// CreateImageSecret mocks base method
+func (m *MockContainerServer) CreateImageSecret(arg0 string) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "CreateImageSecret", arg0)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// CreateImageSecret indicates an expected call of CreateImageSecret
+func (mr *MockContainerServerMockRecorder) CreateImageSecret(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageSecret", reflect.TypeOf((*MockContainerServer)(nil).CreateImageSecret), arg0)
+}
+
+// CreateNetwork mocks base method
+func (m *MockContainerServer) CreateNetwork(arg0 api.NetworksPost) error {
+ ret := m.ctrl.Call(m, "CreateNetwork", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// CreateNetwork indicates an expected call of CreateNetwork
+func (mr *MockContainerServerMockRecorder) CreateNetwork(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetwork", reflect.TypeOf((*MockContainerServer)(nil).CreateNetwork), arg0)
+}
+
+// CreateProfile mocks base method
+func (m *MockContainerServer) CreateProfile(arg0 api.ProfilesPost) error {
+ ret := m.ctrl.Call(m, "CreateProfile", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// CreateProfile indicates an expected call of CreateProfile
+func (mr *MockContainerServerMockRecorder) CreateProfile(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProfile", reflect.TypeOf((*MockContainerServer)(nil).CreateProfile), arg0)
+}
+
+// CreateStoragePool mocks base method
+func (m *MockContainerServer) CreateStoragePool(arg0 api.StoragePoolsPost) error {
+ ret := m.ctrl.Call(m, "CreateStoragePool", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// CreateStoragePool indicates an expected call of CreateStoragePool
+func (mr *MockContainerServerMockRecorder) CreateStoragePool(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoragePool", reflect.TypeOf((*MockContainerServer)(nil).CreateStoragePool), arg0)
+}
+
+// CreateStoragePoolVolume mocks base method
+func (m *MockContainerServer) CreateStoragePoolVolume(arg0 string, arg1 api.StorageVolumesPost) error {
+ ret := m.ctrl.Call(m, "CreateStoragePoolVolume", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// CreateStoragePoolVolume indicates an expected call of CreateStoragePoolVolume
+func (mr *MockContainerServerMockRecorder) CreateStoragePoolVolume(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).CreateStoragePoolVolume), arg0, arg1)
+}
+
+// DeleteCertificate mocks base method
+func (m *MockContainerServer) DeleteCertificate(arg0 string) error {
+ ret := m.ctrl.Call(m, "DeleteCertificate", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteCertificate indicates an expected call of DeleteCertificate
+func (mr *MockContainerServerMockRecorder) DeleteCertificate(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificate", reflect.TypeOf((*MockContainerServer)(nil).DeleteCertificate), arg0)
+}
+
+// DeleteClusterMember mocks base method
+func (m *MockContainerServer) DeleteClusterMember(arg0 string, arg1 bool) error {
+ ret := m.ctrl.Call(m, "DeleteClusterMember", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteClusterMember indicates an expected call of DeleteClusterMember
+func (mr *MockContainerServerMockRecorder) DeleteClusterMember(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterMember", reflect.TypeOf((*MockContainerServer)(nil).DeleteClusterMember), arg0, arg1)
+}
+
+// DeleteContainer mocks base method
+func (m *MockContainerServer) DeleteContainer(arg0 string) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "DeleteContainer", arg0)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// DeleteContainer indicates an expected call of DeleteContainer
+func (mr *MockContainerServerMockRecorder) DeleteContainer(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainer", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainer), arg0)
+}
+
+// DeleteContainerConsoleLog mocks base method
+func (m *MockContainerServer) DeleteContainerConsoleLog(arg0 string, arg1 *client.ContainerConsoleLogArgs) error {
+ ret := m.ctrl.Call(m, "DeleteContainerConsoleLog", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteContainerConsoleLog indicates an expected call of DeleteContainerConsoleLog
+func (mr *MockContainerServerMockRecorder) DeleteContainerConsoleLog(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerConsoleLog", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerConsoleLog), arg0, arg1)
+}
+
+// DeleteContainerFile mocks base method
+func (m *MockContainerServer) DeleteContainerFile(arg0, arg1 string) error {
+ ret := m.ctrl.Call(m, "DeleteContainerFile", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteContainerFile indicates an expected call of DeleteContainerFile
+func (mr *MockContainerServerMockRecorder) DeleteContainerFile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerFile", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerFile), arg0, arg1)
+}
+
+// DeleteContainerLogfile mocks base method
+func (m *MockContainerServer) DeleteContainerLogfile(arg0, arg1 string) error {
+ ret := m.ctrl.Call(m, "DeleteContainerLogfile", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteContainerLogfile indicates an expected call of DeleteContainerLogfile
+func (mr *MockContainerServerMockRecorder) DeleteContainerLogfile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerLogfile", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerLogfile), arg0, arg1)
+}
+
+// DeleteContainerSnapshot mocks base method
+func (m *MockContainerServer) DeleteContainerSnapshot(arg0, arg1 string) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "DeleteContainerSnapshot", arg0, arg1)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// DeleteContainerSnapshot indicates an expected call of DeleteContainerSnapshot
+func (mr *MockContainerServerMockRecorder) DeleteContainerSnapshot(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerSnapshot), arg0, arg1)
+}
+
+// DeleteContainerTemplateFile mocks base method
+func (m *MockContainerServer) DeleteContainerTemplateFile(arg0, arg1 string) error {
+ ret := m.ctrl.Call(m, "DeleteContainerTemplateFile", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteContainerTemplateFile indicates an expected call of DeleteContainerTemplateFile
+func (mr *MockContainerServerMockRecorder) DeleteContainerTemplateFile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerTemplateFile", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerTemplateFile), arg0, arg1)
+}
+
+// DeleteImage mocks base method
+func (m *MockContainerServer) DeleteImage(arg0 string) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "DeleteImage", arg0)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// DeleteImage indicates an expected call of DeleteImage
+func (mr *MockContainerServerMockRecorder) DeleteImage(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImage", reflect.TypeOf((*MockContainerServer)(nil).DeleteImage), arg0)
+}
+
+// DeleteImageAlias mocks base method
+func (m *MockContainerServer) DeleteImageAlias(arg0 string) error {
+ ret := m.ctrl.Call(m, "DeleteImageAlias", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteImageAlias indicates an expected call of DeleteImageAlias
+func (mr *MockContainerServerMockRecorder) DeleteImageAlias(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImageAlias", reflect.TypeOf((*MockContainerServer)(nil).DeleteImageAlias), arg0)
+}
+
+// DeleteNetwork mocks base method
+func (m *MockContainerServer) DeleteNetwork(arg0 string) error {
+ ret := m.ctrl.Call(m, "DeleteNetwork", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteNetwork indicates an expected call of DeleteNetwork
+func (mr *MockContainerServerMockRecorder) DeleteNetwork(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetwork", reflect.TypeOf((*MockContainerServer)(nil).DeleteNetwork), arg0)
+}
+
+// DeleteOperation mocks base method
+func (m *MockContainerServer) DeleteOperation(arg0 string) error {
+ ret := m.ctrl.Call(m, "DeleteOperation", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteOperation indicates an expected call of DeleteOperation
+func (mr *MockContainerServerMockRecorder) DeleteOperation(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOperation", reflect.TypeOf((*MockContainerServer)(nil).DeleteOperation), arg0)
+}
+
+// DeleteProfile mocks base method
+func (m *MockContainerServer) DeleteProfile(arg0 string) error {
+ ret := m.ctrl.Call(m, "DeleteProfile", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteProfile indicates an expected call of DeleteProfile
+func (mr *MockContainerServerMockRecorder) DeleteProfile(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProfile", reflect.TypeOf((*MockContainerServer)(nil).DeleteProfile), arg0)
+}
+
+// DeleteStoragePool mocks base method
+func (m *MockContainerServer) DeleteStoragePool(arg0 string) error {
+ ret := m.ctrl.Call(m, "DeleteStoragePool", arg0)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteStoragePool indicates an expected call of DeleteStoragePool
+func (mr *MockContainerServerMockRecorder) DeleteStoragePool(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStoragePool", reflect.TypeOf((*MockContainerServer)(nil).DeleteStoragePool), arg0)
+}
+
+// DeleteStoragePoolVolume mocks base method
+func (m *MockContainerServer) DeleteStoragePoolVolume(arg0, arg1, arg2 string) error {
+ ret := m.ctrl.Call(m, "DeleteStoragePoolVolume", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// DeleteStoragePoolVolume indicates an expected call of DeleteStoragePoolVolume
+func (mr *MockContainerServerMockRecorder) DeleteStoragePoolVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).DeleteStoragePoolVolume), arg0, arg1, arg2)
+}
+
+// ExecContainer mocks base method
+func (m *MockContainerServer) ExecContainer(arg0 string, arg1 api.ContainerExecPost, arg2 *client.ContainerExecArgs) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "ExecContainer", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// ExecContainer indicates an expected call of ExecContainer
+func (mr *MockContainerServerMockRecorder) ExecContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecContainer", reflect.TypeOf((*MockContainerServer)(nil).ExecContainer), arg0, arg1, arg2)
+}
+
+// GetCertificate mocks base method
+func (m *MockContainerServer) GetCertificate(arg0 string) (*api.Certificate, string, error) {
+ ret := m.ctrl.Call(m, "GetCertificate", arg0)
+ ret0, _ := ret[0].(*api.Certificate)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetCertificate indicates an expected call of GetCertificate
+func (mr *MockContainerServerMockRecorder) GetCertificate(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificate", reflect.TypeOf((*MockContainerServer)(nil).GetCertificate), arg0)
+}
+
+// GetCertificateFingerprints mocks base method
+func (m *MockContainerServer) GetCertificateFingerprints() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetCertificateFingerprints")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetCertificateFingerprints indicates an expected call of GetCertificateFingerprints
+func (mr *MockContainerServerMockRecorder) GetCertificateFingerprints() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificateFingerprints", reflect.TypeOf((*MockContainerServer)(nil).GetCertificateFingerprints))
+}
+
+// GetCertificates mocks base method
+func (m *MockContainerServer) GetCertificates() ([]api.Certificate, error) {
+ ret := m.ctrl.Call(m, "GetCertificates")
+ ret0, _ := ret[0].([]api.Certificate)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetCertificates indicates an expected call of GetCertificates
+func (mr *MockContainerServerMockRecorder) GetCertificates() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificates", reflect.TypeOf((*MockContainerServer)(nil).GetCertificates))
+}
+
+// GetCluster mocks base method
+func (m *MockContainerServer) GetCluster() (*api.Cluster, string, error) {
+ ret := m.ctrl.Call(m, "GetCluster")
+ ret0, _ := ret[0].(*api.Cluster)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetCluster indicates an expected call of GetCluster
+func (mr *MockContainerServerMockRecorder) GetCluster() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockContainerServer)(nil).GetCluster))
+}
+
+// GetClusterMember mocks base method
+func (m *MockContainerServer) GetClusterMember(arg0 string) (*api.ClusterMember, string, error) {
+ ret := m.ctrl.Call(m, "GetClusterMember", arg0)
+ ret0, _ := ret[0].(*api.ClusterMember)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetClusterMember indicates an expected call of GetClusterMember
+func (mr *MockContainerServerMockRecorder) GetClusterMember(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMember", reflect.TypeOf((*MockContainerServer)(nil).GetClusterMember), arg0)
+}
+
+// GetClusterMemberNames mocks base method
+func (m *MockContainerServer) GetClusterMemberNames() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetClusterMemberNames")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetClusterMemberNames indicates an expected call of GetClusterMemberNames
+func (mr *MockContainerServerMockRecorder) GetClusterMemberNames() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMemberNames", reflect.TypeOf((*MockContainerServer)(nil).GetClusterMemberNames))
+}
+
+// GetClusterMembers mocks base method
+func (m *MockContainerServer) GetClusterMembers() ([]api.ClusterMember, error) {
+ ret := m.ctrl.Call(m, "GetClusterMembers")
+ ret0, _ := ret[0].([]api.ClusterMember)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetClusterMembers indicates an expected call of GetClusterMembers
+func (mr *MockContainerServerMockRecorder) GetClusterMembers() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMembers", reflect.TypeOf((*MockContainerServer)(nil).GetClusterMembers))
+}
+
+// GetConnectionInfo mocks base method
+func (m *MockContainerServer) GetConnectionInfo() (*client.ConnectionInfo, error) {
+ ret := m.ctrl.Call(m, "GetConnectionInfo")
+ ret0, _ := ret[0].(*client.ConnectionInfo)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetConnectionInfo indicates an expected call of GetConnectionInfo
+func (mr *MockContainerServerMockRecorder) GetConnectionInfo() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionInfo", reflect.TypeOf((*MockContainerServer)(nil).GetConnectionInfo))
+}
+
+// GetContainer mocks base method
+func (m *MockContainerServer) GetContainer(arg0 string) (*api.Container, string, error) {
+ ret := m.ctrl.Call(m, "GetContainer", arg0)
+ ret0, _ := ret[0].(*api.Container)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetContainer indicates an expected call of GetContainer
+func (mr *MockContainerServerMockRecorder) GetContainer(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainer", reflect.TypeOf((*MockContainerServer)(nil).GetContainer), arg0)
+}
+
+// GetContainerConsoleLog mocks base method
+func (m *MockContainerServer) GetContainerConsoleLog(arg0 string, arg1 *client.ContainerConsoleLogArgs) (io.ReadCloser, error) {
+ ret := m.ctrl.Call(m, "GetContainerConsoleLog", arg0, arg1)
+ ret0, _ := ret[0].(io.ReadCloser)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainerConsoleLog indicates an expected call of GetContainerConsoleLog
+func (mr *MockContainerServerMockRecorder) GetContainerConsoleLog(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerConsoleLog", reflect.TypeOf((*MockContainerServer)(nil).GetContainerConsoleLog), arg0, arg1)
+}
+
+// GetContainerFile mocks base method
+func (m *MockContainerServer) GetContainerFile(arg0, arg1 string) (io.ReadCloser, *client.ContainerFileResponse, error) {
+ ret := m.ctrl.Call(m, "GetContainerFile", arg0, arg1)
+ ret0, _ := ret[0].(io.ReadCloser)
+ ret1, _ := ret[1].(*client.ContainerFileResponse)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetContainerFile indicates an expected call of GetContainerFile
+func (mr *MockContainerServerMockRecorder) GetContainerFile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerFile", reflect.TypeOf((*MockContainerServer)(nil).GetContainerFile), arg0, arg1)
+}
+
+// GetContainerLogfile mocks base method
+func (m *MockContainerServer) GetContainerLogfile(arg0, arg1 string) (io.ReadCloser, error) {
+ ret := m.ctrl.Call(m, "GetContainerLogfile", arg0, arg1)
+ ret0, _ := ret[0].(io.ReadCloser)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainerLogfile indicates an expected call of GetContainerLogfile
+func (mr *MockContainerServerMockRecorder) GetContainerLogfile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerLogfile", reflect.TypeOf((*MockContainerServer)(nil).GetContainerLogfile), arg0, arg1)
+}
+
+// GetContainerLogfiles mocks base method
+func (m *MockContainerServer) GetContainerLogfiles(arg0 string) ([]string, error) {
+ ret := m.ctrl.Call(m, "GetContainerLogfiles", arg0)
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainerLogfiles indicates an expected call of GetContainerLogfiles
+func (mr *MockContainerServerMockRecorder) GetContainerLogfiles(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerLogfiles", reflect.TypeOf((*MockContainerServer)(nil).GetContainerLogfiles), arg0)
+}
+
+// GetContainerMetadata mocks base method
+func (m *MockContainerServer) GetContainerMetadata(arg0 string) (*api.ImageMetadata, string, error) {
+ ret := m.ctrl.Call(m, "GetContainerMetadata", arg0)
+ ret0, _ := ret[0].(*api.ImageMetadata)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetContainerMetadata indicates an expected call of GetContainerMetadata
+func (mr *MockContainerServerMockRecorder) GetContainerMetadata(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerMetadata", reflect.TypeOf((*MockContainerServer)(nil).GetContainerMetadata), arg0)
+}
+
+// GetContainerNames mocks base method
+func (m *MockContainerServer) GetContainerNames() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetContainerNames")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainerNames indicates an expected call of GetContainerNames
+func (mr *MockContainerServerMockRecorder) GetContainerNames() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerNames", reflect.TypeOf((*MockContainerServer)(nil).GetContainerNames))
+}
+
+// GetContainerSnapshot mocks base method
+func (m *MockContainerServer) GetContainerSnapshot(arg0, arg1 string) (*api.ContainerSnapshot, string, error) {
+ ret := m.ctrl.Call(m, "GetContainerSnapshot", arg0, arg1)
+ ret0, _ := ret[0].(*api.ContainerSnapshot)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetContainerSnapshot indicates an expected call of GetContainerSnapshot
+func (mr *MockContainerServerMockRecorder) GetContainerSnapshot(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).GetContainerSnapshot), arg0, arg1)
+}
+
+// GetContainerSnapshotNames mocks base method
+func (m *MockContainerServer) GetContainerSnapshotNames(arg0 string) ([]string, error) {
+ ret := m.ctrl.Call(m, "GetContainerSnapshotNames", arg0)
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainerSnapshotNames indicates an expected call of GetContainerSnapshotNames
+func (mr *MockContainerServerMockRecorder) GetContainerSnapshotNames(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerSnapshotNames", reflect.TypeOf((*MockContainerServer)(nil).GetContainerSnapshotNames), arg0)
+}
+
+// GetContainerSnapshots mocks base method
+func (m *MockContainerServer) GetContainerSnapshots(arg0 string) ([]api.ContainerSnapshot, error) {
+ ret := m.ctrl.Call(m, "GetContainerSnapshots", arg0)
+ ret0, _ := ret[0].([]api.ContainerSnapshot)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainerSnapshots indicates an expected call of GetContainerSnapshots
+func (mr *MockContainerServerMockRecorder) GetContainerSnapshots(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerSnapshots", reflect.TypeOf((*MockContainerServer)(nil).GetContainerSnapshots), arg0)
+}
+
+// GetContainerState mocks base method
+func (m *MockContainerServer) GetContainerState(arg0 string) (*api.ContainerState, string, error) {
+ ret := m.ctrl.Call(m, "GetContainerState", arg0)
+ ret0, _ := ret[0].(*api.ContainerState)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetContainerState indicates an expected call of GetContainerState
+func (mr *MockContainerServerMockRecorder) GetContainerState(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerState", reflect.TypeOf((*MockContainerServer)(nil).GetContainerState), arg0)
+}
+
+// GetContainerTemplateFile mocks base method
+func (m *MockContainerServer) GetContainerTemplateFile(arg0, arg1 string) (io.ReadCloser, error) {
+ ret := m.ctrl.Call(m, "GetContainerTemplateFile", arg0, arg1)
+ ret0, _ := ret[0].(io.ReadCloser)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainerTemplateFile indicates an expected call of GetContainerTemplateFile
+func (mr *MockContainerServerMockRecorder) GetContainerTemplateFile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerTemplateFile", reflect.TypeOf((*MockContainerServer)(nil).GetContainerTemplateFile), arg0, arg1)
+}
+
+// GetContainerTemplateFiles mocks base method
+func (m *MockContainerServer) GetContainerTemplateFiles(arg0 string) ([]string, error) {
+ ret := m.ctrl.Call(m, "GetContainerTemplateFiles", arg0)
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainerTemplateFiles indicates an expected call of GetContainerTemplateFiles
+func (mr *MockContainerServerMockRecorder) GetContainerTemplateFiles(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerTemplateFiles", reflect.TypeOf((*MockContainerServer)(nil).GetContainerTemplateFiles), arg0)
+}
+
+// GetContainers mocks base method
+func (m *MockContainerServer) GetContainers() ([]api.Container, error) {
+ ret := m.ctrl.Call(m, "GetContainers")
+ ret0, _ := ret[0].([]api.Container)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetContainers indicates an expected call of GetContainers
+func (mr *MockContainerServerMockRecorder) GetContainers() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainers", reflect.TypeOf((*MockContainerServer)(nil).GetContainers))
+}
+
+// GetEvents mocks base method
+func (m *MockContainerServer) GetEvents() (*client.EventListener, error) {
+ ret := m.ctrl.Call(m, "GetEvents")
+ ret0, _ := ret[0].(*client.EventListener)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetEvents indicates an expected call of GetEvents
+func (mr *MockContainerServerMockRecorder) GetEvents() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEvents", reflect.TypeOf((*MockContainerServer)(nil).GetEvents))
+}
+
+// GetHTTPClient mocks base method
+func (m *MockContainerServer) GetHTTPClient() (*http.Client, error) {
+ ret := m.ctrl.Call(m, "GetHTTPClient")
+ ret0, _ := ret[0].(*http.Client)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetHTTPClient indicates an expected call of GetHTTPClient
+func (mr *MockContainerServerMockRecorder) GetHTTPClient() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHTTPClient", reflect.TypeOf((*MockContainerServer)(nil).GetHTTPClient))
+}
+
+// GetImage mocks base method
+func (m *MockContainerServer) GetImage(arg0 string) (*api.Image, string, error) {
+ ret := m.ctrl.Call(m, "GetImage", arg0)
+ ret0, _ := ret[0].(*api.Image)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetImage indicates an expected call of GetImage
+func (mr *MockContainerServerMockRecorder) GetImage(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImage", reflect.TypeOf((*MockContainerServer)(nil).GetImage), arg0)
+}
+
+// GetImageAlias mocks base method
+func (m *MockContainerServer) GetImageAlias(arg0 string) (*api.ImageAliasesEntry, string, error) {
+ ret := m.ctrl.Call(m, "GetImageAlias", arg0)
+ ret0, _ := ret[0].(*api.ImageAliasesEntry)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetImageAlias indicates an expected call of GetImageAlias
+func (mr *MockContainerServerMockRecorder) GetImageAlias(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAlias", reflect.TypeOf((*MockContainerServer)(nil).GetImageAlias), arg0)
+}
+
+// GetImageAliasNames mocks base method
+func (m *MockContainerServer) GetImageAliasNames() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetImageAliasNames")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageAliasNames indicates an expected call of GetImageAliasNames
+func (mr *MockContainerServerMockRecorder) GetImageAliasNames() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAliasNames", reflect.TypeOf((*MockContainerServer)(nil).GetImageAliasNames))
+}
+
+// GetImageAliases mocks base method
+func (m *MockContainerServer) GetImageAliases() ([]api.ImageAliasesEntry, error) {
+ ret := m.ctrl.Call(m, "GetImageAliases")
+ ret0, _ := ret[0].([]api.ImageAliasesEntry)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageAliases indicates an expected call of GetImageAliases
+func (mr *MockContainerServerMockRecorder) GetImageAliases() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAliases", reflect.TypeOf((*MockContainerServer)(nil).GetImageAliases))
+}
+
+// GetImageFile mocks base method
+func (m *MockContainerServer) GetImageFile(arg0 string, arg1 client.ImageFileRequest) (*client.ImageFileResponse, error) {
+ ret := m.ctrl.Call(m, "GetImageFile", arg0, arg1)
+ ret0, _ := ret[0].(*client.ImageFileResponse)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageFile indicates an expected call of GetImageFile
+func (mr *MockContainerServerMockRecorder) GetImageFile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageFile", reflect.TypeOf((*MockContainerServer)(nil).GetImageFile), arg0, arg1)
+}
+
+// GetImageFingerprints mocks base method
+func (m *MockContainerServer) GetImageFingerprints() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetImageFingerprints")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageFingerprints indicates an expected call of GetImageFingerprints
+func (mr *MockContainerServerMockRecorder) GetImageFingerprints() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageFingerprints", reflect.TypeOf((*MockContainerServer)(nil).GetImageFingerprints))
+}
+
+// GetImageSecret mocks base method
+func (m *MockContainerServer) GetImageSecret(arg0 string) (string, error) {
+ ret := m.ctrl.Call(m, "GetImageSecret", arg0)
+ ret0, _ := ret[0].(string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImageSecret indicates an expected call of GetImageSecret
+func (mr *MockContainerServerMockRecorder) GetImageSecret(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageSecret", reflect.TypeOf((*MockContainerServer)(nil).GetImageSecret), arg0)
+}
+
+// GetImages mocks base method
+func (m *MockContainerServer) GetImages() ([]api.Image, error) {
+ ret := m.ctrl.Call(m, "GetImages")
+ ret0, _ := ret[0].([]api.Image)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetImages indicates an expected call of GetImages
+func (mr *MockContainerServerMockRecorder) GetImages() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImages", reflect.TypeOf((*MockContainerServer)(nil).GetImages))
+}
+
+// GetNetwork mocks base method
+func (m *MockContainerServer) GetNetwork(arg0 string) (*api.Network, string, error) {
+ ret := m.ctrl.Call(m, "GetNetwork", arg0)
+ ret0, _ := ret[0].(*api.Network)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetNetwork indicates an expected call of GetNetwork
+func (mr *MockContainerServerMockRecorder) GetNetwork(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetwork", reflect.TypeOf((*MockContainerServer)(nil).GetNetwork), arg0)
+}
+
+// GetNetworkLeases mocks base method
+func (m *MockContainerServer) GetNetworkLeases(arg0 string) ([]api.NetworkLease, error) {
+ ret := m.ctrl.Call(m, "GetNetworkLeases", arg0)
+ ret0, _ := ret[0].([]api.NetworkLease)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetNetworkLeases indicates an expected call of GetNetworkLeases
+func (mr *MockContainerServerMockRecorder) GetNetworkLeases(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkLeases", reflect.TypeOf((*MockContainerServer)(nil).GetNetworkLeases), arg0)
+}
+
+// GetNetworkNames mocks base method
+func (m *MockContainerServer) GetNetworkNames() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetNetworkNames")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetNetworkNames indicates an expected call of GetNetworkNames
+func (mr *MockContainerServerMockRecorder) GetNetworkNames() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkNames", reflect.TypeOf((*MockContainerServer)(nil).GetNetworkNames))
+}
+
+// GetNetworks mocks base method
+func (m *MockContainerServer) GetNetworks() ([]api.Network, error) {
+ ret := m.ctrl.Call(m, "GetNetworks")
+ ret0, _ := ret[0].([]api.Network)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetNetworks indicates an expected call of GetNetworks
+func (mr *MockContainerServerMockRecorder) GetNetworks() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworks", reflect.TypeOf((*MockContainerServer)(nil).GetNetworks))
+}
+
+// GetOperation mocks base method
+func (m *MockContainerServer) GetOperation(arg0 string) (*api.Operation, string, error) {
+ ret := m.ctrl.Call(m, "GetOperation", arg0)
+ ret0, _ := ret[0].(*api.Operation)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetOperation indicates an expected call of GetOperation
+func (mr *MockContainerServerMockRecorder) GetOperation(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperation", reflect.TypeOf((*MockContainerServer)(nil).GetOperation), arg0)
+}
+
+// GetOperationUUIDs mocks base method
+func (m *MockContainerServer) GetOperationUUIDs() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetOperationUUIDs")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetOperationUUIDs indicates an expected call of GetOperationUUIDs
+func (mr *MockContainerServerMockRecorder) GetOperationUUIDs() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperationUUIDs", reflect.TypeOf((*MockContainerServer)(nil).GetOperationUUIDs))
+}
+
+// GetOperationWebsocket mocks base method
+func (m *MockContainerServer) GetOperationWebsocket(arg0, arg1 string) (*websocket.Conn, error) {
+ ret := m.ctrl.Call(m, "GetOperationWebsocket", arg0, arg1)
+ ret0, _ := ret[0].(*websocket.Conn)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetOperationWebsocket indicates an expected call of GetOperationWebsocket
+func (mr *MockContainerServerMockRecorder) GetOperationWebsocket(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperationWebsocket", reflect.TypeOf((*MockContainerServer)(nil).GetOperationWebsocket), arg0, arg1)
+}
+
+// GetOperations mocks base method
+func (m *MockContainerServer) GetOperations() ([]api.Operation, error) {
+ ret := m.ctrl.Call(m, "GetOperations")
+ ret0, _ := ret[0].([]api.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetOperations indicates an expected call of GetOperations
+func (mr *MockContainerServerMockRecorder) GetOperations() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperations", reflect.TypeOf((*MockContainerServer)(nil).GetOperations))
+}
+
+// GetPrivateImage mocks base method
+func (m *MockContainerServer) GetPrivateImage(arg0, arg1 string) (*api.Image, string, error) {
+ ret := m.ctrl.Call(m, "GetPrivateImage", arg0, arg1)
+ ret0, _ := ret[0].(*api.Image)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetPrivateImage indicates an expected call of GetPrivateImage
+func (mr *MockContainerServerMockRecorder) GetPrivateImage(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateImage", reflect.TypeOf((*MockContainerServer)(nil).GetPrivateImage), arg0, arg1)
+}
+
+// GetPrivateImageFile mocks base method
+func (m *MockContainerServer) GetPrivateImageFile(arg0, arg1 string, arg2 client.ImageFileRequest) (*client.ImageFileResponse, error) {
+ ret := m.ctrl.Call(m, "GetPrivateImageFile", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.ImageFileResponse)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetPrivateImageFile indicates an expected call of GetPrivateImageFile
+func (mr *MockContainerServerMockRecorder) GetPrivateImageFile(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateImageFile", reflect.TypeOf((*MockContainerServer)(nil).GetPrivateImageFile), arg0, arg1, arg2)
+}
+
+// GetProfile mocks base method
+func (m *MockContainerServer) GetProfile(arg0 string) (*api.Profile, string, error) {
+ ret := m.ctrl.Call(m, "GetProfile", arg0)
+ ret0, _ := ret[0].(*api.Profile)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetProfile indicates an expected call of GetProfile
+func (mr *MockContainerServerMockRecorder) GetProfile(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProfile", reflect.TypeOf((*MockContainerServer)(nil).GetProfile), arg0)
+}
+
+// GetProfileNames mocks base method
+func (m *MockContainerServer) GetProfileNames() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetProfileNames")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetProfileNames indicates an expected call of GetProfileNames
+func (mr *MockContainerServerMockRecorder) GetProfileNames() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProfileNames", reflect.TypeOf((*MockContainerServer)(nil).GetProfileNames))
+}
+
+// GetProfiles mocks base method
+func (m *MockContainerServer) GetProfiles() ([]api.Profile, error) {
+ ret := m.ctrl.Call(m, "GetProfiles")
+ ret0, _ := ret[0].([]api.Profile)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetProfiles indicates an expected call of GetProfiles
+func (mr *MockContainerServerMockRecorder) GetProfiles() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProfiles", reflect.TypeOf((*MockContainerServer)(nil).GetProfiles))
+}
+
+// GetServer mocks base method
+func (m *MockContainerServer) GetServer() (*api.Server, string, error) {
+ ret := m.ctrl.Call(m, "GetServer")
+ ret0, _ := ret[0].(*api.Server)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetServer indicates an expected call of GetServer
+func (mr *MockContainerServerMockRecorder) GetServer() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServer", reflect.TypeOf((*MockContainerServer)(nil).GetServer))
+}
+
+// GetServerResources mocks base method
+func (m *MockContainerServer) GetServerResources() (*api.Resources, error) {
+ ret := m.ctrl.Call(m, "GetServerResources")
+ ret0, _ := ret[0].(*api.Resources)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetServerResources indicates an expected call of GetServerResources
+func (mr *MockContainerServerMockRecorder) GetServerResources() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerResources", reflect.TypeOf((*MockContainerServer)(nil).GetServerResources))
+}
+
+// GetStoragePool mocks base method
+func (m *MockContainerServer) GetStoragePool(arg0 string) (*api.StoragePool, string, error) {
+ ret := m.ctrl.Call(m, "GetStoragePool", arg0)
+ ret0, _ := ret[0].(*api.StoragePool)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetStoragePool indicates an expected call of GetStoragePool
+func (mr *MockContainerServerMockRecorder) GetStoragePool(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePool", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePool), arg0)
+}
+
+// GetStoragePoolNames mocks base method
+func (m *MockContainerServer) GetStoragePoolNames() ([]string, error) {
+ ret := m.ctrl.Call(m, "GetStoragePoolNames")
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetStoragePoolNames indicates an expected call of GetStoragePoolNames
+func (mr *MockContainerServerMockRecorder) GetStoragePoolNames() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolNames", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolNames))
+}
+
+// GetStoragePoolResources mocks base method
+func (m *MockContainerServer) GetStoragePoolResources(arg0 string) (*api.ResourcesStoragePool, error) {
+ ret := m.ctrl.Call(m, "GetStoragePoolResources", arg0)
+ ret0, _ := ret[0].(*api.ResourcesStoragePool)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetStoragePoolResources indicates an expected call of GetStoragePoolResources
+func (mr *MockContainerServerMockRecorder) GetStoragePoolResources(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolResources", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolResources), arg0)
+}
+
+// GetStoragePoolVolume mocks base method
+func (m *MockContainerServer) GetStoragePoolVolume(arg0, arg1, arg2 string) (*api.StorageVolume, string, error) {
+ ret := m.ctrl.Call(m, "GetStoragePoolVolume", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*api.StorageVolume)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// GetStoragePoolVolume indicates an expected call of GetStoragePoolVolume
+func (mr *MockContainerServerMockRecorder) GetStoragePoolVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolume), arg0, arg1, arg2)
+}
+
+// GetStoragePoolVolumeNames mocks base method
+func (m *MockContainerServer) GetStoragePoolVolumeNames(arg0 string) ([]string, error) {
+ ret := m.ctrl.Call(m, "GetStoragePoolVolumeNames", arg0)
+ ret0, _ := ret[0].([]string)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetStoragePoolVolumeNames indicates an expected call of GetStoragePoolVolumeNames
+func (mr *MockContainerServerMockRecorder) GetStoragePoolVolumeNames(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumeNames", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolumeNames), arg0)
+}
+
+// GetStoragePoolVolumes mocks base method
+func (m *MockContainerServer) GetStoragePoolVolumes(arg0 string) ([]api.StorageVolume, error) {
+ ret := m.ctrl.Call(m, "GetStoragePoolVolumes", arg0)
+ ret0, _ := ret[0].([]api.StorageVolume)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetStoragePoolVolumes indicates an expected call of GetStoragePoolVolumes
+func (mr *MockContainerServerMockRecorder) GetStoragePoolVolumes(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumes", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolumes), arg0)
+}
+
+// GetStoragePools mocks base method
+func (m *MockContainerServer) GetStoragePools() ([]api.StoragePool, error) {
+ ret := m.ctrl.Call(m, "GetStoragePools")
+ ret0, _ := ret[0].([]api.StoragePool)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// GetStoragePools indicates an expected call of GetStoragePools
+func (mr *MockContainerServerMockRecorder) GetStoragePools() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePools", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePools))
+}
+
+// HasExtension mocks base method
+func (m *MockContainerServer) HasExtension(arg0 string) bool {
+ ret := m.ctrl.Call(m, "HasExtension", arg0)
+ ret0, _ := ret[0].(bool)
+ return ret0
+}
+
+// HasExtension indicates an expected call of HasExtension
+func (mr *MockContainerServerMockRecorder) HasExtension(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasExtension", reflect.TypeOf((*MockContainerServer)(nil).HasExtension), arg0)
+}
+
+// IsClustered mocks base method
+func (m *MockContainerServer) IsClustered() bool {
+ ret := m.ctrl.Call(m, "IsClustered")
+ ret0, _ := ret[0].(bool)
+ return ret0
+}
+
+// IsClustered indicates an expected call of IsClustered
+func (mr *MockContainerServerMockRecorder) IsClustered() *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsClustered", reflect.TypeOf((*MockContainerServer)(nil).IsClustered))
+}
+
+// MigrateContainer mocks base method
+func (m *MockContainerServer) MigrateContainer(arg0 string, arg1 api.ContainerPost) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "MigrateContainer", arg0, arg1)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// MigrateContainer indicates an expected call of MigrateContainer
+func (mr *MockContainerServerMockRecorder) MigrateContainer(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateContainer", reflect.TypeOf((*MockContainerServer)(nil).MigrateContainer), arg0, arg1)
+}
+
+// MigrateContainerSnapshot mocks base method
+func (m *MockContainerServer) MigrateContainerSnapshot(arg0, arg1 string, arg2 api.ContainerSnapshotPost) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "MigrateContainerSnapshot", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// MigrateContainerSnapshot indicates an expected call of MigrateContainerSnapshot
+func (mr *MockContainerServerMockRecorder) MigrateContainerSnapshot(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).MigrateContainerSnapshot), arg0, arg1, arg2)
+}
+
+// MoveStoragePoolVolume mocks base method
+func (m *MockContainerServer) MoveStoragePoolVolume(arg0 string, arg1 client.ContainerServer, arg2 string, arg3 api.StorageVolume, arg4 *client.StoragePoolVolumeMoveArgs) (*client.RemoteOperation, error) {
+ ret := m.ctrl.Call(m, "MoveStoragePoolVolume", arg0, arg1, arg2, arg3, arg4)
+ ret0, _ := ret[0].(*client.RemoteOperation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// MoveStoragePoolVolume indicates an expected call of MoveStoragePoolVolume
+func (mr *MockContainerServerMockRecorder) MoveStoragePoolVolume(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).MoveStoragePoolVolume), arg0, arg1, arg2, arg3, arg4)
+}
+
+// RawOperation mocks base method
+func (m *MockContainerServer) RawOperation(arg0, arg1 string, arg2 interface{}, arg3 string) (*client.Operation, string, error) {
+ ret := m.ctrl.Call(m, "RawOperation", arg0, arg1, arg2, arg3)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// RawOperation indicates an expected call of RawOperation
+func (mr *MockContainerServerMockRecorder) RawOperation(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawOperation", reflect.TypeOf((*MockContainerServer)(nil).RawOperation), arg0, arg1, arg2, arg3)
+}
+
+// RawQuery mocks base method
+func (m *MockContainerServer) RawQuery(arg0, arg1 string, arg2 interface{}, arg3 string) (*api.Response, string, error) {
+ ret := m.ctrl.Call(m, "RawQuery", arg0, arg1, arg2, arg3)
+ ret0, _ := ret[0].(*api.Response)
+ ret1, _ := ret[1].(string)
+ ret2, _ := ret[2].(error)
+ return ret0, ret1, ret2
+}
+
+// RawQuery indicates an expected call of RawQuery
+func (mr *MockContainerServerMockRecorder) RawQuery(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawQuery", reflect.TypeOf((*MockContainerServer)(nil).RawQuery), arg0, arg1, arg2, arg3)
+}
+
+// RawWebsocket mocks base method
+func (m *MockContainerServer) RawWebsocket(arg0 string) (*websocket.Conn, error) {
+ ret := m.ctrl.Call(m, "RawWebsocket", arg0)
+ ret0, _ := ret[0].(*websocket.Conn)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// RawWebsocket indicates an expected call of RawWebsocket
+func (mr *MockContainerServerMockRecorder) RawWebsocket(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawWebsocket", reflect.TypeOf((*MockContainerServer)(nil).RawWebsocket), arg0)
+}
+
+// RefreshImage mocks base method
+func (m *MockContainerServer) RefreshImage(arg0 string) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "RefreshImage", arg0)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// RefreshImage indicates an expected call of RefreshImage
+func (mr *MockContainerServerMockRecorder) RefreshImage(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshImage", reflect.TypeOf((*MockContainerServer)(nil).RefreshImage), arg0)
+}
+
+// RenameClusterMember mocks base method
+func (m *MockContainerServer) RenameClusterMember(arg0 string, arg1 api.ClusterMemberPost) error {
+ ret := m.ctrl.Call(m, "RenameClusterMember", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// RenameClusterMember indicates an expected call of RenameClusterMember
+func (mr *MockContainerServerMockRecorder) RenameClusterMember(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameClusterMember", reflect.TypeOf((*MockContainerServer)(nil).RenameClusterMember), arg0, arg1)
+}
+
+// RenameContainer mocks base method
+func (m *MockContainerServer) RenameContainer(arg0 string, arg1 api.ContainerPost) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "RenameContainer", arg0, arg1)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// RenameContainer indicates an expected call of RenameContainer
+func (mr *MockContainerServerMockRecorder) RenameContainer(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameContainer", reflect.TypeOf((*MockContainerServer)(nil).RenameContainer), arg0, arg1)
+}
+
+// RenameContainerSnapshot mocks base method
+func (m *MockContainerServer) RenameContainerSnapshot(arg0, arg1 string, arg2 api.ContainerSnapshotPost) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "RenameContainerSnapshot", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// RenameContainerSnapshot indicates an expected call of RenameContainerSnapshot
+func (mr *MockContainerServerMockRecorder) RenameContainerSnapshot(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).RenameContainerSnapshot), arg0, arg1, arg2)
+}
+
+// RenameImageAlias mocks base method
+func (m *MockContainerServer) RenameImageAlias(arg0 string, arg1 api.ImageAliasesEntryPost) error {
+ ret := m.ctrl.Call(m, "RenameImageAlias", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// RenameImageAlias indicates an expected call of RenameImageAlias
+func (mr *MockContainerServerMockRecorder) RenameImageAlias(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameImageAlias", reflect.TypeOf((*MockContainerServer)(nil).RenameImageAlias), arg0, arg1)
+}
+
+// RenameNetwork mocks base method
+func (m *MockContainerServer) RenameNetwork(arg0 string, arg1 api.NetworkPost) error {
+ ret := m.ctrl.Call(m, "RenameNetwork", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// RenameNetwork indicates an expected call of RenameNetwork
+func (mr *MockContainerServerMockRecorder) RenameNetwork(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNetwork", reflect.TypeOf((*MockContainerServer)(nil).RenameNetwork), arg0, arg1)
+}
+
+// RenameProfile mocks base method
+func (m *MockContainerServer) RenameProfile(arg0 string, arg1 api.ProfilePost) error {
+ ret := m.ctrl.Call(m, "RenameProfile", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// RenameProfile indicates an expected call of RenameProfile
+func (mr *MockContainerServerMockRecorder) RenameProfile(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameProfile", reflect.TypeOf((*MockContainerServer)(nil).RenameProfile), arg0, arg1)
+}
+
+// RenameStoragePoolVolume mocks base method
+func (m *MockContainerServer) RenameStoragePoolVolume(arg0, arg1, arg2 string, arg3 api.StorageVolumePost) error {
+ ret := m.ctrl.Call(m, "RenameStoragePoolVolume", arg0, arg1, arg2, arg3)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// RenameStoragePoolVolume indicates an expected call of RenameStoragePoolVolume
+func (mr *MockContainerServerMockRecorder) RenameStoragePoolVolume(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).RenameStoragePoolVolume), arg0, arg1, arg2, arg3)
+}
+
+// RequireAuthenticated mocks base method
+func (m *MockContainerServer) RequireAuthenticated(arg0 bool) {
+ m.ctrl.Call(m, "RequireAuthenticated", arg0)
+}
+
+// RequireAuthenticated indicates an expected call of RequireAuthenticated
+func (mr *MockContainerServerMockRecorder) RequireAuthenticated(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequireAuthenticated", reflect.TypeOf((*MockContainerServer)(nil).RequireAuthenticated), arg0)
+}
+
+// SetContainerMetadata mocks base method
+func (m *MockContainerServer) SetContainerMetadata(arg0 string, arg1 api.ImageMetadata, arg2 string) error {
+ ret := m.ctrl.Call(m, "SetContainerMetadata", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// SetContainerMetadata indicates an expected call of SetContainerMetadata
+func (mr *MockContainerServerMockRecorder) SetContainerMetadata(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContainerMetadata", reflect.TypeOf((*MockContainerServer)(nil).SetContainerMetadata), arg0, arg1, arg2)
+}
+
+// UpdateCertificate mocks base method
+func (m *MockContainerServer) UpdateCertificate(arg0 string, arg1 api.CertificatePut, arg2 string) error {
+ ret := m.ctrl.Call(m, "UpdateCertificate", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateCertificate indicates an expected call of UpdateCertificate
+func (mr *MockContainerServerMockRecorder) UpdateCertificate(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCertificate", reflect.TypeOf((*MockContainerServer)(nil).UpdateCertificate), arg0, arg1, arg2)
+}
+
+// UpdateCluster mocks base method
+func (m *MockContainerServer) UpdateCluster(arg0 api.ClusterPut, arg1 string) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "UpdateCluster", arg0, arg1)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// UpdateCluster indicates an expected call of UpdateCluster
+func (mr *MockContainerServerMockRecorder) UpdateCluster(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockContainerServer)(nil).UpdateCluster), arg0, arg1)
+}
+
+// UpdateContainer mocks base method
+func (m *MockContainerServer) UpdateContainer(arg0 string, arg1 api.ContainerPut, arg2 string) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "UpdateContainer", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// UpdateContainer indicates an expected call of UpdateContainer
+func (mr *MockContainerServerMockRecorder) UpdateContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainer", reflect.TypeOf((*MockContainerServer)(nil).UpdateContainer), arg0, arg1, arg2)
+}
+
+// UpdateContainerState mocks base method
+func (m *MockContainerServer) UpdateContainerState(arg0 string, arg1 api.ContainerStatePut, arg2 string) (*client.Operation, error) {
+ ret := m.ctrl.Call(m, "UpdateContainerState", arg0, arg1, arg2)
+ ret0, _ := ret[0].(*client.Operation)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// UpdateContainerState indicates an expected call of UpdateContainerState
+func (mr *MockContainerServerMockRecorder) UpdateContainerState(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerState", reflect.TypeOf((*MockContainerServer)(nil).UpdateContainerState), arg0, arg1, arg2)
+}
+
+// UpdateContainerTemplateFile mocks base method
+func (m *MockContainerServer) UpdateContainerTemplateFile(arg0, arg1 string, arg2 io.ReadSeeker) error {
+ ret := m.ctrl.Call(m, "UpdateContainerTemplateFile", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateContainerTemplateFile indicates an expected call of UpdateContainerTemplateFile
+func (mr *MockContainerServerMockRecorder) UpdateContainerTemplateFile(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerTemplateFile", reflect.TypeOf((*MockContainerServer)(nil).UpdateContainerTemplateFile), arg0, arg1, arg2)
+}
+
+// UpdateImage mocks base method
+func (m *MockContainerServer) UpdateImage(arg0 string, arg1 api.ImagePut, arg2 string) error {
+ ret := m.ctrl.Call(m, "UpdateImage", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateImage indicates an expected call of UpdateImage
+func (mr *MockContainerServerMockRecorder) UpdateImage(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImage", reflect.TypeOf((*MockContainerServer)(nil).UpdateImage), arg0, arg1, arg2)
+}
+
+// UpdateImageAlias mocks base method
+func (m *MockContainerServer) UpdateImageAlias(arg0 string, arg1 api.ImageAliasesEntryPut, arg2 string) error {
+ ret := m.ctrl.Call(m, "UpdateImageAlias", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateImageAlias indicates an expected call of UpdateImageAlias
+func (mr *MockContainerServerMockRecorder) UpdateImageAlias(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImageAlias", reflect.TypeOf((*MockContainerServer)(nil).UpdateImageAlias), arg0, arg1, arg2)
+}
+
+// UpdateNetwork mocks base method
+func (m *MockContainerServer) UpdateNetwork(arg0 string, arg1 api.NetworkPut, arg2 string) error {
+ ret := m.ctrl.Call(m, "UpdateNetwork", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateNetwork indicates an expected call of UpdateNetwork
+func (mr *MockContainerServerMockRecorder) UpdateNetwork(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNetwork", reflect.TypeOf((*MockContainerServer)(nil).UpdateNetwork), arg0, arg1, arg2)
+}
+
+// UpdateProfile mocks base method
+func (m *MockContainerServer) UpdateProfile(arg0 string, arg1 api.ProfilePut, arg2 string) error {
+ ret := m.ctrl.Call(m, "UpdateProfile", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateProfile indicates an expected call of UpdateProfile
+func (mr *MockContainerServerMockRecorder) UpdateProfile(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProfile", reflect.TypeOf((*MockContainerServer)(nil).UpdateProfile), arg0, arg1, arg2)
+}
+
+// UpdateServer mocks base method
+func (m *MockContainerServer) UpdateServer(arg0 api.ServerPut, arg1 string) error {
+ ret := m.ctrl.Call(m, "UpdateServer", arg0, arg1)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateServer indicates an expected call of UpdateServer
+func (mr *MockContainerServerMockRecorder) UpdateServer(arg0, arg1 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServer", reflect.TypeOf((*MockContainerServer)(nil).UpdateServer), arg0, arg1)
+}
+
+// UpdateStoragePool mocks base method
+func (m *MockContainerServer) UpdateStoragePool(arg0 string, arg1 api.StoragePoolPut, arg2 string) error {
+ ret := m.ctrl.Call(m, "UpdateStoragePool", arg0, arg1, arg2)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateStoragePool indicates an expected call of UpdateStoragePool
+func (mr *MockContainerServerMockRecorder) UpdateStoragePool(arg0, arg1, arg2 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStoragePool", reflect.TypeOf((*MockContainerServer)(nil).UpdateStoragePool), arg0, arg1, arg2)
+}
+
+// UpdateStoragePoolVolume mocks base method
+func (m *MockContainerServer) UpdateStoragePoolVolume(arg0, arg1, arg2 string, arg3 api.StorageVolumePut, arg4 string) error {
+ ret := m.ctrl.Call(m, "UpdateStoragePoolVolume", arg0, arg1, arg2, arg3, arg4)
+ ret0, _ := ret[0].(error)
+ return ret0
+}
+
+// UpdateStoragePoolVolume indicates an expected call of UpdateStoragePoolVolume
+func (mr *MockContainerServerMockRecorder) UpdateStoragePoolVolume(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).UpdateStoragePoolVolume), arg0, arg1, arg2, arg3, arg4)
+}
+
+// UseTarget mocks base method
+func (m *MockContainerServer) UseTarget(arg0 string) client.ContainerServer {
+ ret := m.ctrl.Call(m, "UseTarget", arg0)
+ ret0, _ := ret[0].(client.ContainerServer)
+ return ret0
+}
+
+// UseTarget indicates an expected call of UseTarget
+func (mr *MockContainerServerMockRecorder) UseTarget(arg0 interface{}) *gomock.Call {
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseTarget", reflect.TypeOf((*MockContainerServer)(nil).UseTarget), arg0)
+}
More information about the lxc-devel
mailing list