From: Lukasz Wojciechowski Date: Thu, 23 Nov 2017 17:01:10 +0000 (+0100) Subject: Add generated mockup for boruta.Requests X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F16%2F162016%2F4;p=tools%2Fweles.git Add generated mockup for boruta.Requests mockgen -source=${GOPATH}/src/git.tizen.org/tools/boruta/boruta.go -destination=controller/mock/requests.go -package mock -imports ".=git.tizen.org/tools/boruta" Change-Id: I3cd7673db7ff0eb5e7fb3ead8ea3d31a83430bee Signed-off-by: Lukasz Wojciechowski --- diff --git a/controller/mock/requests.go b/controller/mock/requests.go new file mode 100644 index 0000000..ed4b075 --- /dev/null +++ b/controller/mock/requests.go @@ -0,0 +1,351 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /home/l.wojciechow/go//src/git.tizen.org/tools/boruta/boruta.go + +// Package mock is a generated GoMock package. +package mock + +import ( + rsa "crypto/rsa" + . "git.tizen.org/tools/boruta" + gomock "github.com/golang/mock/gomock" + reflect "reflect" + time "time" +) + +// MockListFilter is a mock of ListFilter interface +type MockListFilter struct { + ctrl *gomock.Controller + recorder *MockListFilterMockRecorder +} + +// MockListFilterMockRecorder is the mock recorder for MockListFilter +type MockListFilterMockRecorder struct { + mock *MockListFilter +} + +// NewMockListFilter creates a new mock instance +func NewMockListFilter(ctrl *gomock.Controller) *MockListFilter { + mock := &MockListFilter{ctrl: ctrl} + mock.recorder = &MockListFilterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockListFilter) EXPECT() *MockListFilterMockRecorder { + return m.recorder +} + +// Match mocks base method +func (m *MockListFilter) Match(req *ReqInfo) bool { + ret := m.ctrl.Call(m, "Match", req) + ret0, _ := ret[0].(bool) + return ret0 +} + +// Match indicates an expected call of Match +func (mr *MockListFilterMockRecorder) Match(req interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Match", reflect.TypeOf((*MockListFilter)(nil).Match), req) +} + +// MockRequests is a mock of Requests interface +type MockRequests struct { + ctrl *gomock.Controller + recorder *MockRequestsMockRecorder +} + +// MockRequestsMockRecorder is the mock recorder for MockRequests +type MockRequestsMockRecorder struct { + mock *MockRequests +} + +// NewMockRequests creates a new mock instance +func NewMockRequests(ctrl *gomock.Controller) *MockRequests { + mock := &MockRequests{ctrl: ctrl} + mock.recorder = &MockRequestsMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockRequests) EXPECT() *MockRequestsMockRecorder { + return m.recorder +} + +// NewRequest mocks base method +func (m *MockRequests) NewRequest(caps Capabilities, priority Priority, owner UserInfo, validAfter, deadline time.Time) (ReqID, error) { + ret := m.ctrl.Call(m, "NewRequest", caps, priority, owner, validAfter, deadline) + ret0, _ := ret[0].(ReqID) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NewRequest indicates an expected call of NewRequest +func (mr *MockRequestsMockRecorder) NewRequest(caps, priority, owner, validAfter, deadline interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRequest", reflect.TypeOf((*MockRequests)(nil).NewRequest), caps, priority, owner, validAfter, deadline) +} + +// CloseRequest mocks base method +func (m *MockRequests) CloseRequest(reqID ReqID) error { + ret := m.ctrl.Call(m, "CloseRequest", reqID) + ret0, _ := ret[0].(error) + return ret0 +} + +// CloseRequest indicates an expected call of CloseRequest +func (mr *MockRequestsMockRecorder) CloseRequest(reqID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseRequest", reflect.TypeOf((*MockRequests)(nil).CloseRequest), reqID) +} + +// UpdateRequest mocks base method +func (m *MockRequests) UpdateRequest(reqInfo *ReqInfo) error { + ret := m.ctrl.Call(m, "UpdateRequest", reqInfo) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateRequest indicates an expected call of UpdateRequest +func (mr *MockRequestsMockRecorder) UpdateRequest(reqInfo interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRequest", reflect.TypeOf((*MockRequests)(nil).UpdateRequest), reqInfo) +} + +// GetRequestInfo mocks base method +func (m *MockRequests) GetRequestInfo(reqID ReqID) (ReqInfo, error) { + ret := m.ctrl.Call(m, "GetRequestInfo", reqID) + ret0, _ := ret[0].(ReqInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRequestInfo indicates an expected call of GetRequestInfo +func (mr *MockRequestsMockRecorder) GetRequestInfo(reqID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequestInfo", reflect.TypeOf((*MockRequests)(nil).GetRequestInfo), reqID) +} + +// ListRequests mocks base method +func (m *MockRequests) ListRequests(filter ListFilter) ([]ReqInfo, error) { + ret := m.ctrl.Call(m, "ListRequests", filter) + ret0, _ := ret[0].([]ReqInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRequests indicates an expected call of ListRequests +func (mr *MockRequestsMockRecorder) ListRequests(filter interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRequests", reflect.TypeOf((*MockRequests)(nil).ListRequests), filter) +} + +// AcquireWorker mocks base method +func (m *MockRequests) AcquireWorker(reqID ReqID) (AccessInfo, error) { + ret := m.ctrl.Call(m, "AcquireWorker", reqID) + ret0, _ := ret[0].(AccessInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcquireWorker indicates an expected call of AcquireWorker +func (mr *MockRequestsMockRecorder) AcquireWorker(reqID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireWorker", reflect.TypeOf((*MockRequests)(nil).AcquireWorker), reqID) +} + +// ProlongAccess mocks base method +func (m *MockRequests) ProlongAccess(reqID ReqID) error { + ret := m.ctrl.Call(m, "ProlongAccess", reqID) + ret0, _ := ret[0].(error) + return ret0 +} + +// ProlongAccess indicates an expected call of ProlongAccess +func (mr *MockRequestsMockRecorder) ProlongAccess(reqID interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProlongAccess", reflect.TypeOf((*MockRequests)(nil).ProlongAccess), reqID) +} + +// MockSuperviser is a mock of Superviser interface +type MockSuperviser struct { + ctrl *gomock.Controller + recorder *MockSuperviserMockRecorder +} + +// MockSuperviserMockRecorder is the mock recorder for MockSuperviser +type MockSuperviserMockRecorder struct { + mock *MockSuperviser +} + +// NewMockSuperviser creates a new mock instance +func NewMockSuperviser(ctrl *gomock.Controller) *MockSuperviser { + mock := &MockSuperviser{ctrl: ctrl} + mock.recorder = &MockSuperviserMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockSuperviser) EXPECT() *MockSuperviserMockRecorder { + return m.recorder +} + +// Register mocks base method +func (m *MockSuperviser) Register(caps Capabilities) error { + ret := m.ctrl.Call(m, "Register", caps) + ret0, _ := ret[0].(error) + return ret0 +} + +// Register indicates an expected call of Register +func (mr *MockSuperviserMockRecorder) Register(caps interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockSuperviser)(nil).Register), caps) +} + +// SetFail mocks base method +func (m *MockSuperviser) SetFail(uuid WorkerUUID, reason string) error { + ret := m.ctrl.Call(m, "SetFail", uuid, reason) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetFail indicates an expected call of SetFail +func (mr *MockSuperviserMockRecorder) SetFail(uuid, reason interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFail", reflect.TypeOf((*MockSuperviser)(nil).SetFail), uuid, reason) +} + +// MockWorkers is a mock of Workers interface +type MockWorkers struct { + ctrl *gomock.Controller + recorder *MockWorkersMockRecorder +} + +// MockWorkersMockRecorder is the mock recorder for MockWorkers +type MockWorkersMockRecorder struct { + mock *MockWorkers +} + +// NewMockWorkers creates a new mock instance +func NewMockWorkers(ctrl *gomock.Controller) *MockWorkers { + mock := &MockWorkers{ctrl: ctrl} + mock.recorder = &MockWorkersMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockWorkers) EXPECT() *MockWorkersMockRecorder { + return m.recorder +} + +// ListWorkers mocks base method +func (m *MockWorkers) ListWorkers(groups Groups, caps Capabilities) ([]WorkerInfo, error) { + ret := m.ctrl.Call(m, "ListWorkers", groups, caps) + ret0, _ := ret[0].([]WorkerInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListWorkers indicates an expected call of ListWorkers +func (mr *MockWorkersMockRecorder) ListWorkers(groups, caps interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkers", reflect.TypeOf((*MockWorkers)(nil).ListWorkers), groups, caps) +} + +// GetWorkerInfo mocks base method +func (m *MockWorkers) GetWorkerInfo(uuid WorkerUUID) (WorkerInfo, error) { + ret := m.ctrl.Call(m, "GetWorkerInfo", uuid) + ret0, _ := ret[0].(WorkerInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWorkerInfo indicates an expected call of GetWorkerInfo +func (mr *MockWorkersMockRecorder) GetWorkerInfo(uuid interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkerInfo", reflect.TypeOf((*MockWorkers)(nil).GetWorkerInfo), uuid) +} + +// SetState mocks base method +func (m *MockWorkers) SetState(uuid WorkerUUID, state WorkerState) error { + ret := m.ctrl.Call(m, "SetState", uuid, state) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetState indicates an expected call of SetState +func (mr *MockWorkersMockRecorder) SetState(uuid, state interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockWorkers)(nil).SetState), uuid, state) +} + +// SetGroups mocks base method +func (m *MockWorkers) SetGroups(uuid WorkerUUID, groups Groups) error { + ret := m.ctrl.Call(m, "SetGroups", uuid, groups) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetGroups indicates an expected call of SetGroups +func (mr *MockWorkersMockRecorder) SetGroups(uuid, groups interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGroups", reflect.TypeOf((*MockWorkers)(nil).SetGroups), uuid, groups) +} + +// Deregister mocks base method +func (m *MockWorkers) Deregister(uuid WorkerUUID) error { + ret := m.ctrl.Call(m, "Deregister", uuid) + ret0, _ := ret[0].(error) + return ret0 +} + +// Deregister indicates an expected call of Deregister +func (mr *MockWorkersMockRecorder) Deregister(uuid interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deregister", reflect.TypeOf((*MockWorkers)(nil).Deregister), uuid) +} + +// MockDryad is a mock of Dryad interface +type MockDryad struct { + ctrl *gomock.Controller + recorder *MockDryadMockRecorder +} + +// MockDryadMockRecorder is the mock recorder for MockDryad +type MockDryadMockRecorder struct { + mock *MockDryad +} + +// NewMockDryad creates a new mock instance +func NewMockDryad(ctrl *gomock.Controller) *MockDryad { + mock := &MockDryad{ctrl: ctrl} + mock.recorder = &MockDryadMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockDryad) EXPECT() *MockDryadMockRecorder { + return m.recorder +} + +// PutInMaintenance mocks base method +func (m *MockDryad) PutInMaintenance(msg string) error { + ret := m.ctrl.Call(m, "PutInMaintenance", msg) + ret0, _ := ret[0].(error) + return ret0 +} + +// PutInMaintenance indicates an expected call of PutInMaintenance +func (mr *MockDryadMockRecorder) PutInMaintenance(msg interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutInMaintenance", reflect.TypeOf((*MockDryad)(nil).PutInMaintenance), msg) +} + +// Prepare mocks base method +func (m *MockDryad) Prepare() (*rsa.PrivateKey, error) { + ret := m.ctrl.Call(m, "Prepare") + ret0, _ := ret[0].(*rsa.PrivateKey) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Prepare indicates an expected call of Prepare +func (mr *MockDryadMockRecorder) Prepare() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockDryad)(nil).Prepare)) +} + +// Healthcheck mocks base method +func (m *MockDryad) Healthcheck() error { + ret := m.ctrl.Call(m, "Healthcheck") + ret0, _ := ret[0].(error) + return ret0 +} + +// Healthcheck indicates an expected call of Healthcheck +func (mr *MockDryadMockRecorder) Healthcheck() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Healthcheck", reflect.TypeOf((*MockDryad)(nil).Healthcheck)) +}