generated_mock_libvirt.go

// Automatically generated by MockGen. DO NOT EDIT!
// Source: libvirt.go

package cli

import (
	gomock "github.com/golang/mock/gomock"
	libvirt_go "github.com/libvirt/libvirt-go"
)

// Mock of Connection interface
type MockConnection struct {
	ctrl     *gomock.Controller
	recorder *_MockConnectionRecorder
}

// Recorder for MockConnection (not exported)
type _MockConnectionRecorder struct {
	mock *MockConnection
}

func NewMockConnection(ctrl *gomock.Controller) *MockConnection {
	mock := &MockConnection{ctrl: ctrl}
	mock.recorder = &_MockConnectionRecorder{mock}
	return mock
}

func (_m *MockConnection) EXPECT() *_MockConnectionRecorder {
	return _m.recorder
}

func (_m *MockConnection) LookupDomainByName(name string) (VirDomain, error) {
	ret := _m.ctrl.Call(_m, "LookupDomainByName", name)
	ret0, _ := ret[0].(VirDomain)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) LookupDomainByName(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "LookupDomainByName", arg0)
}

func (_m *MockConnection) DomainDefineXML(xml string) (VirDomain, error) {
	ret := _m.ctrl.Call(_m, "DomainDefineXML", xml)
	ret0, _ := ret[0].(VirDomain)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) DomainDefineXML(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DomainDefineXML", arg0)
}

func (_m *MockConnection) Close() (int, error) {
	ret := _m.ctrl.Call(_m, "Close")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) Close() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
}

func (_m *MockConnection) DomainEventLifecycleRegister(callback libvirt_go.DomainEventLifecycleCallback) error {
	ret := _m.ctrl.Call(_m, "DomainEventLifecycleRegister", callback)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockConnectionRecorder) DomainEventLifecycleRegister(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DomainEventLifecycleRegister", arg0)
}

func (_m *MockConnection) ListAllDomains(flags libvirt_go.ConnectListAllDomainsFlags) ([]VirDomain, error) {
	ret := _m.ctrl.Call(_m, "ListAllDomains", flags)
	ret0, _ := ret[0].([]VirDomain)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) ListAllDomains(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListAllDomains", arg0)
}

func (_m *MockConnection) NewStream(flags libvirt_go.StreamFlags) (Stream, error) {
	ret := _m.ctrl.Call(_m, "NewStream", flags)
	ret0, _ := ret[0].(Stream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) NewStream(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "NewStream", arg0)
}

func (_m *MockConnection) LookupSecretByUsage(usageType libvirt_go.SecretUsageType, usageID string) (VirSecret, error) {
	ret := _m.ctrl.Call(_m, "LookupSecretByUsage", usageType, usageID)
	ret0, _ := ret[0].(VirSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) LookupSecretByUsage(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "LookupSecretByUsage", arg0, arg1)
}

func (_m *MockConnection) SecretDefineXML(xml string) (VirSecret, error) {
	ret := _m.ctrl.Call(_m, "SecretDefineXML", xml)
	ret0, _ := ret[0].(VirSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) SecretDefineXML(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SecretDefineXML", arg0)
}

func (_m *MockConnection) ListSecrets() ([]string, error) {
	ret := _m.ctrl.Call(_m, "ListSecrets")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) ListSecrets() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListSecrets")
}

func (_m *MockConnection) LookupSecretByUUIDString(uuid string) (VirSecret, error) {
	ret := _m.ctrl.Call(_m, "LookupSecretByUUIDString", uuid)
	ret0, _ := ret[0].(VirSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) LookupSecretByUUIDString(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "LookupSecretByUUIDString", arg0)
}

func (_m *MockConnection) ListAllSecrets(flags libvirt_go.ConnectListAllSecretsFlags) ([]VirSecret, error) {
	ret := _m.ctrl.Call(_m, "ListAllSecrets", flags)
	ret0, _ := ret[0].([]VirSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockConnectionRecorder) ListAllSecrets(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListAllSecrets", arg0)
}

// Mock of Stream interface
type MockStream struct {
	ctrl     *gomock.Controller
	recorder *_MockStreamRecorder
}

// Recorder for MockStream (not exported)
type _MockStreamRecorder struct {
	mock *MockStream
}

func NewMockStream(ctrl *gomock.Controller) *MockStream {
	mock := &MockStream{ctrl: ctrl}
	mock.recorder = &_MockStreamRecorder{mock}
	return mock
}

func (_m *MockStream) EXPECT() *_MockStreamRecorder {
	return _m.recorder
}

func (_m *MockStream) Read(p []byte) (int, error) {
	ret := _m.ctrl.Call(_m, "Read", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockStreamRecorder) Read(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Read", arg0)
}

func (_m *MockStream) Write(p []byte) (int, error) {
	ret := _m.ctrl.Call(_m, "Write", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockStreamRecorder) Write(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0)
}

func (_m *MockStream) Close() error {
	ret := _m.ctrl.Call(_m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockStreamRecorder) Close() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
}

func (_m *MockStream) UnderlyingStream() *libvirt_go.Stream {
	ret := _m.ctrl.Call(_m, "UnderlyingStream")
	ret0, _ := ret[0].(*libvirt_go.Stream)
	return ret0
}

func (_mr *_MockStreamRecorder) UnderlyingStream() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UnderlyingStream")
}

// Mock of VirSecret interface
type MockVirSecret struct {
	ctrl     *gomock.Controller
	recorder *_MockVirSecretRecorder
}

// Recorder for MockVirSecret (not exported)
type _MockVirSecretRecorder struct {
	mock *MockVirSecret
}

func NewMockVirSecret(ctrl *gomock.Controller) *MockVirSecret {
	mock := &MockVirSecret{ctrl: ctrl}
	mock.recorder = &_MockVirSecretRecorder{mock}
	return mock
}

func (_m *MockVirSecret) EXPECT() *_MockVirSecretRecorder {
	return _m.recorder
}

func (_m *MockVirSecret) SetValue(value []byte, flags uint32) error {
	ret := _m.ctrl.Call(_m, "SetValue", value, flags)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirSecretRecorder) SetValue(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetValue", arg0, arg1)
}

func (_m *MockVirSecret) Undefine() error {
	ret := _m.ctrl.Call(_m, "Undefine")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirSecretRecorder) Undefine() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Undefine")
}

func (_m *MockVirSecret) GetUsageID() (string, error) {
	ret := _m.ctrl.Call(_m, "GetUsageID")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirSecretRecorder) GetUsageID() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetUsageID")
}

func (_m *MockVirSecret) GetUUIDString() (string, error) {
	ret := _m.ctrl.Call(_m, "GetUUIDString")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirSecretRecorder) GetUUIDString() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetUUIDString")
}

func (_m *MockVirSecret) GetXMLDesc(flags uint32) (string, error) {
	ret := _m.ctrl.Call(_m, "GetXMLDesc", flags)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirSecretRecorder) GetXMLDesc(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetXMLDesc", arg0)
}

func (_m *MockVirSecret) Free() error {
	ret := _m.ctrl.Call(_m, "Free")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirSecretRecorder) Free() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Free")
}

// Mock of VirDomain interface
type MockVirDomain struct {
	ctrl     *gomock.Controller
	recorder *_MockVirDomainRecorder
}

// Recorder for MockVirDomain (not exported)
type _MockVirDomainRecorder struct {
	mock *MockVirDomain
}

func NewMockVirDomain(ctrl *gomock.Controller) *MockVirDomain {
	mock := &MockVirDomain{ctrl: ctrl}
	mock.recorder = &_MockVirDomainRecorder{mock}
	return mock
}

func (_m *MockVirDomain) EXPECT() *_MockVirDomainRecorder {
	return _m.recorder
}

func (_m *MockVirDomain) GetState() (libvirt_go.DomainState, int, error) {
	ret := _m.ctrl.Call(_m, "GetState")
	ret0, _ := ret[0].(libvirt_go.DomainState)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

func (_mr *_MockVirDomainRecorder) GetState() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetState")
}

func (_m *MockVirDomain) Create() error {
	ret := _m.ctrl.Call(_m, "Create")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirDomainRecorder) Create() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Create")
}

func (_m *MockVirDomain) Resume() error {
	ret := _m.ctrl.Call(_m, "Resume")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirDomainRecorder) Resume() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Resume")
}

func (_m *MockVirDomain) Destroy() error {
	ret := _m.ctrl.Call(_m, "Destroy")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirDomainRecorder) Destroy() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Destroy")
}

func (_m *MockVirDomain) GetName() (string, error) {
	ret := _m.ctrl.Call(_m, "GetName")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirDomainRecorder) GetName() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetName")
}

func (_m *MockVirDomain) GetUUIDString() (string, error) {
	ret := _m.ctrl.Call(_m, "GetUUIDString")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirDomainRecorder) GetUUIDString() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetUUIDString")
}

func (_m *MockVirDomain) GetXMLDesc(flags libvirt_go.DomainXMLFlags) (string, error) {
	ret := _m.ctrl.Call(_m, "GetXMLDesc", flags)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirDomainRecorder) GetXMLDesc(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetXMLDesc", arg0)
}

func (_m *MockVirDomain) Undefine() error {
	ret := _m.ctrl.Call(_m, "Undefine")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirDomainRecorder) Undefine() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Undefine")
}

func (_m *MockVirDomain) OpenConsole(devname string, stream *libvirt_go.Stream, flags libvirt_go.DomainConsoleFlags) error {
	ret := _m.ctrl.Call(_m, "OpenConsole", devname, stream, flags)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirDomainRecorder) OpenConsole(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "OpenConsole", arg0, arg1, arg2)
}

func (_m *MockVirDomain) Free() error {
	ret := _m.ctrl.Call(_m, "Free")
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirDomainRecorder) Free() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Free")
}