github.com/jingruilea/kubeedge@v1.2.0-beta.0.0.20200410162146-4bb8902b3879/edge/mocks/beego/fake_ormer.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/astaxie/beego/orm (interfaces: Ormer)

// Package beego is a generated GoMock package.
package beego

import (
	"context"
	sql "database/sql"
	reflect "reflect"

	orm "github.com/astaxie/beego/orm"
	gomock "github.com/golang/mock/gomock"
)

// MockOrmer is a mock of Ormer interface
type MockOrmer struct {
	ctrl     *gomock.Controller
	recorder *MockOrmerMockRecorder
}

// MockOrmerMockRecorder is the mock recorder for MockOrmer
type MockOrmerMockRecorder struct {
	mock *MockOrmer
}

// NewMockOrmer creates a new mock instance
func NewMockOrmer(ctrl *gomock.Controller) *MockOrmer {
	mock := &MockOrmer{ctrl: ctrl}
	mock.recorder = &MockOrmerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockOrmer) EXPECT() *MockOrmerMockRecorder {
	return m.recorder
}

// Begin mocks base method
func (m *MockOrmer) Begin() error {
	ret := m.ctrl.Call(m, "Begin")
	ret0, _ := ret[0].(error)
	return ret0
}

// Begin indicates an expected call of Begin
func (mr *MockOrmerMockRecorder) Begin() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockOrmer)(nil).Begin))
}

// BeginTx mocks base method
func (m *MockOrmer) BeginTx(arg0 context.Context, arg1 *sql.TxOptions) error {
	ret := m.ctrl.Call(m, "BeginTx", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Begin indicates an expected call of Begin
func (mr *MockOrmerMockRecorder) BeginTx(arg0 context.Context, arg1 *sql.TxOptions) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginTx", reflect.TypeOf((*MockOrmer)(nil).BeginTx), arg0, arg1)
}

// Commit mocks base method
func (m *MockOrmer) Commit() error {
	ret := m.ctrl.Call(m, "Commit")
	ret0, _ := ret[0].(error)
	return ret0
}

// Commit indicates an expected call of Commit
func (mr *MockOrmerMockRecorder) Commit() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockOrmer)(nil).Commit))
}

// Delete mocks base method
func (m *MockOrmer) Delete(arg0 interface{}, arg1 ...string) (int64, error) {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete
func (mr *MockOrmerMockRecorder) Delete(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOrmer)(nil).Delete), varargs...)
}

// Driver mocks base method
func (m *MockOrmer) Driver() orm.Driver {
	ret := m.ctrl.Call(m, "Driver")
	ret0, _ := ret[0].(orm.Driver)
	return ret0
}

// Driver indicates an expected call of Driver
func (mr *MockOrmerMockRecorder) Driver() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Driver", reflect.TypeOf((*MockOrmer)(nil).Driver))
}

// DBStats mocks base method
func (m *MockOrmer) DBStats() *sql.DBStats {
	ret := m.ctrl.Call(m, "DBStats")
	ret0, _ := ret[0].(*sql.DBStats)
	return ret0
}

// DBStats indicates an expected call of DBStats
func (mr *MockOrmerMockRecorder) DBStats() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBStats", reflect.TypeOf((*MockOrmer)(nil).DBStats))
}

// Insert mocks base method
func (m *MockOrmer) Insert(arg0 interface{}) (int64, error) {
	ret := m.ctrl.Call(m, "Insert", arg0)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Insert indicates an expected call of Insert
func (mr *MockOrmerMockRecorder) Insert(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockOrmer)(nil).Insert), arg0)
}

// InsertMulti mocks base method
func (m *MockOrmer) InsertMulti(arg0 int, arg1 interface{}) (int64, error) {
	ret := m.ctrl.Call(m, "InsertMulti", arg0, arg1)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertMulti indicates an expected call of InsertMulti
func (mr *MockOrmerMockRecorder) InsertMulti(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMulti", reflect.TypeOf((*MockOrmer)(nil).InsertMulti), arg0, arg1)
}

// InsertOrUpdate mocks base method
func (m *MockOrmer) InsertOrUpdate(arg0 interface{}, arg1 ...string) (int64, error) {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "InsertOrUpdate", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOrUpdate indicates an expected call of InsertOrUpdate
func (mr *MockOrmerMockRecorder) InsertOrUpdate(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOrUpdate", reflect.TypeOf((*MockOrmer)(nil).InsertOrUpdate), varargs...)
}

// LoadRelated mocks base method
func (m *MockOrmer) LoadRelated(arg0 interface{}, arg1 string, arg2 ...interface{}) (int64, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LoadRelated", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadRelated indicates an expected call of LoadRelated
func (mr *MockOrmerMockRecorder) LoadRelated(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadRelated", reflect.TypeOf((*MockOrmer)(nil).LoadRelated), varargs...)
}

// QueryM2M mocks base method
func (m *MockOrmer) QueryM2M(arg0 interface{}, arg1 string) orm.QueryM2Mer {
	ret := m.ctrl.Call(m, "QueryM2M", arg0, arg1)
	ret0, _ := ret[0].(orm.QueryM2Mer)
	return ret0
}

// QueryM2M indicates an expected call of QueryM2M
func (mr *MockOrmerMockRecorder) QueryM2M(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryM2M", reflect.TypeOf((*MockOrmer)(nil).QueryM2M), arg0, arg1)
}

// QueryTable mocks base method
func (m *MockOrmer) QueryTable(arg0 interface{}) orm.QuerySeter {
	ret := m.ctrl.Call(m, "QueryTable", arg0)
	ret0, _ := ret[0].(orm.QuerySeter)
	return ret0
}

// QueryTable indicates an expected call of QueryTable
func (mr *MockOrmerMockRecorder) QueryTable(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTable", reflect.TypeOf((*MockOrmer)(nil).QueryTable), arg0)
}

// Raw mocks base method
func (m *MockOrmer) Raw(arg0 string, arg1 ...interface{}) orm.RawSeter {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Raw", varargs...)
	ret0, _ := ret[0].(orm.RawSeter)
	return ret0
}

// Raw indicates an expected call of Raw
func (mr *MockOrmerMockRecorder) Raw(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Raw", reflect.TypeOf((*MockOrmer)(nil).Raw), varargs...)
}

// Read mocks base method
func (m *MockOrmer) Read(arg0 interface{}, arg1 ...string) error {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Read", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Read indicates an expected call of Read
func (mr *MockOrmerMockRecorder) Read(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockOrmer)(nil).Read), varargs...)
}

// ReadForUpdate mocks base method
func (m *MockOrmer) ReadForUpdate(arg0 interface{}, arg1 ...string) error {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReadForUpdate", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReadForUpdate indicates an expected call of ReadForUpdate
func (mr *MockOrmerMockRecorder) ReadForUpdate(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadForUpdate", reflect.TypeOf((*MockOrmer)(nil).ReadForUpdate), varargs...)
}

// ReadOrCreate mocks base method
func (m *MockOrmer) ReadOrCreate(arg0 interface{}, arg1 string, arg2 ...string) (bool, int64, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReadOrCreate", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadOrCreate indicates an expected call of ReadOrCreate
func (mr *MockOrmerMockRecorder) ReadOrCreate(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOrCreate", reflect.TypeOf((*MockOrmer)(nil).ReadOrCreate), varargs...)
}

// Rollback mocks base method
func (m *MockOrmer) Rollback() error {
	ret := m.ctrl.Call(m, "Rollback")
	ret0, _ := ret[0].(error)
	return ret0
}

// Rollback indicates an expected call of Rollback
func (mr *MockOrmerMockRecorder) Rollback() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockOrmer)(nil).Rollback))
}

// Update mocks base method
func (m *MockOrmer) Update(arg0 interface{}, arg1 ...string) (int64, error) {
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update
func (mr *MockOrmerMockRecorder) Update(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockOrmer)(nil).Update), varargs...)
}

// Using mocks base method
func (m *MockOrmer) Using(arg0 string) error {
	ret := m.ctrl.Call(m, "Using", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Using indicates an expected call of Using
func (mr *MockOrmerMockRecorder) Using(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Using", reflect.TypeOf((*MockOrmer)(nil).Using), arg0)
}