mock_tx_database.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/skygeario/skygear-server/pkg/server/skydb (interfaces: TxDatabase)

package mock_skydb

import (
	gomock "github.com/golang/mock/gomock"
	skydb "github.com/skygeario/skygear-server/pkg/server/skydb"
	reflect "reflect"
)

// MockTxDatabase is a mock of TxDatabase interface
type MockTxDatabase struct {
	ctrl     *gomock.Controller
	recorder *MockTxDatabaseMockRecorder
}

// MockTxDatabaseMockRecorder is the mock recorder for MockTxDatabase
type MockTxDatabaseMockRecorder struct {
	mock *MockTxDatabase
}

// NewMockTxDatabase creates a new mock instance
func NewMockTxDatabase(ctrl *gomock.Controller) *MockTxDatabase {
	mock := &MockTxDatabase{ctrl: ctrl}
	mock.recorder = &MockTxDatabaseMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (_m *MockTxDatabase) EXPECT() *MockTxDatabaseMockRecorder {
	return _m.recorder
}

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

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

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

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

// Conn mocks base method
func (_m *MockTxDatabase) Conn() skydb.Conn {
	ret := _m.ctrl.Call(_m, "Conn")
	ret0, _ := ret[0].(skydb.Conn)
	return ret0
}

// Conn indicates an expected call of Conn
func (_mr *MockTxDatabaseMockRecorder) Conn() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Conn", reflect.TypeOf((*MockTxDatabase)(nil).Conn))
}

// DatabaseType mocks base method
func (_m *MockTxDatabase) DatabaseType() skydb.DatabaseType {
	ret := _m.ctrl.Call(_m, "DatabaseType")
	ret0, _ := ret[0].(skydb.DatabaseType)
	return ret0
}

// DatabaseType indicates an expected call of DatabaseType
func (_mr *MockTxDatabaseMockRecorder) DatabaseType() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "DatabaseType", reflect.TypeOf((*MockTxDatabase)(nil).DatabaseType))
}

// Delete mocks base method
func (_m *MockTxDatabase) Delete(_param0 skydb.RecordID) error {
	ret := _m.ctrl.Call(_m, "Delete", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (_mr *MockTxDatabaseMockRecorder) Delete(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Delete", reflect.TypeOf((*MockTxDatabase)(nil).Delete), arg0)
}

// DeleteIndex mocks base method
func (_m *MockTxDatabase) DeleteIndex(_param0 string, _param1 string) error {
	ret := _m.ctrl.Call(_m, "DeleteIndex", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteIndex indicates an expected call of DeleteIndex
func (_mr *MockTxDatabaseMockRecorder) DeleteIndex(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "DeleteIndex", reflect.TypeOf((*MockTxDatabase)(nil).DeleteIndex), arg0, arg1)
}

// DeleteSchema mocks base method
func (_m *MockTxDatabase) DeleteSchema(_param0 string, _param1 string) error {
	ret := _m.ctrl.Call(_m, "DeleteSchema", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSchema indicates an expected call of DeleteSchema
func (_mr *MockTxDatabaseMockRecorder) DeleteSchema(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "DeleteSchema", reflect.TypeOf((*MockTxDatabase)(nil).DeleteSchema), arg0, arg1)
}

// DeleteSubscription mocks base method
func (_m *MockTxDatabase) DeleteSubscription(_param0 string, _param1 string) error {
	ret := _m.ctrl.Call(_m, "DeleteSubscription", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSubscription indicates an expected call of DeleteSubscription
func (_mr *MockTxDatabaseMockRecorder) DeleteSubscription(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "DeleteSubscription", reflect.TypeOf((*MockTxDatabase)(nil).DeleteSubscription), arg0, arg1)
}

// Extend mocks base method
func (_m *MockTxDatabase) Extend(_param0 string, _param1 skydb.RecordSchema) (bool, error) {
	ret := _m.ctrl.Call(_m, "Extend", _param0, _param1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Extend indicates an expected call of Extend
func (_mr *MockTxDatabaseMockRecorder) Extend(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Extend", reflect.TypeOf((*MockTxDatabase)(nil).Extend), arg0, arg1)
}

// Get mocks base method
func (_m *MockTxDatabase) Get(_param0 skydb.RecordID, _param1 *skydb.Record) error {
	ret := _m.ctrl.Call(_m, "Get", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Get indicates an expected call of Get
func (_mr *MockTxDatabaseMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Get", reflect.TypeOf((*MockTxDatabase)(nil).Get), arg0, arg1)
}

// GetByIDs mocks base method
func (_m *MockTxDatabase) GetByIDs(_param0 []skydb.RecordID, _param1 *skydb.AccessControlOptions) (*skydb.Rows, error) {
	ret := _m.ctrl.Call(_m, "GetByIDs", _param0, _param1)
	ret0, _ := ret[0].(*skydb.Rows)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByIDs indicates an expected call of GetByIDs
func (_mr *MockTxDatabaseMockRecorder) GetByIDs(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetByIDs", reflect.TypeOf((*MockTxDatabase)(nil).GetByIDs), arg0, arg1)
}

// GetIndexesByRecordType mocks base method
func (_m *MockTxDatabase) GetIndexesByRecordType(_param0 string) (map[string]skydb.Index, error) {
	ret := _m.ctrl.Call(_m, "GetIndexesByRecordType", _param0)
	ret0, _ := ret[0].(map[string]skydb.Index)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIndexesByRecordType indicates an expected call of GetIndexesByRecordType
func (_mr *MockTxDatabaseMockRecorder) GetIndexesByRecordType(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetIndexesByRecordType", reflect.TypeOf((*MockTxDatabase)(nil).GetIndexesByRecordType), arg0)
}

// GetMatchingSubscriptions mocks base method
func (_m *MockTxDatabase) GetMatchingSubscriptions(_param0 *skydb.Record) []skydb.Subscription {
	ret := _m.ctrl.Call(_m, "GetMatchingSubscriptions", _param0)
	ret0, _ := ret[0].([]skydb.Subscription)
	return ret0
}

// GetMatchingSubscriptions indicates an expected call of GetMatchingSubscriptions
func (_mr *MockTxDatabaseMockRecorder) GetMatchingSubscriptions(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetMatchingSubscriptions", reflect.TypeOf((*MockTxDatabase)(nil).GetMatchingSubscriptions), arg0)
}

// GetRecordSchemas mocks base method
func (_m *MockTxDatabase) GetRecordSchemas() (map[string]skydb.RecordSchema, error) {
	ret := _m.ctrl.Call(_m, "GetRecordSchemas")
	ret0, _ := ret[0].(map[string]skydb.RecordSchema)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRecordSchemas indicates an expected call of GetRecordSchemas
func (_mr *MockTxDatabaseMockRecorder) GetRecordSchemas() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetRecordSchemas", reflect.TypeOf((*MockTxDatabase)(nil).GetRecordSchemas))
}

// GetSchema mocks base method
func (_m *MockTxDatabase) GetSchema(_param0 string) (skydb.RecordSchema, error) {
	ret := _m.ctrl.Call(_m, "GetSchema", _param0)
	ret0, _ := ret[0].(skydb.RecordSchema)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSchema indicates an expected call of GetSchema
func (_mr *MockTxDatabaseMockRecorder) GetSchema(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetSchema", reflect.TypeOf((*MockTxDatabase)(nil).GetSchema), arg0)
}

// GetSubscription mocks base method
func (_m *MockTxDatabase) GetSubscription(_param0 string, _param1 string, _param2 *skydb.Subscription) error {
	ret := _m.ctrl.Call(_m, "GetSubscription", _param0, _param1, _param2)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetSubscription indicates an expected call of GetSubscription
func (_mr *MockTxDatabaseMockRecorder) GetSubscription(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetSubscription", reflect.TypeOf((*MockTxDatabase)(nil).GetSubscription), arg0, arg1, arg2)
}

// GetSubscriptionsByDeviceID mocks base method
func (_m *MockTxDatabase) GetSubscriptionsByDeviceID(_param0 string) []skydb.Subscription {
	ret := _m.ctrl.Call(_m, "GetSubscriptionsByDeviceID", _param0)
	ret0, _ := ret[0].([]skydb.Subscription)
	return ret0
}

// GetSubscriptionsByDeviceID indicates an expected call of GetSubscriptionsByDeviceID
func (_mr *MockTxDatabaseMockRecorder) GetSubscriptionsByDeviceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "GetSubscriptionsByDeviceID", reflect.TypeOf((*MockTxDatabase)(nil).GetSubscriptionsByDeviceID), arg0)
}

// ID mocks base method
func (_m *MockTxDatabase) ID() string {
	ret := _m.ctrl.Call(_m, "ID")
	ret0, _ := ret[0].(string)
	return ret0
}

// ID indicates an expected call of ID
func (_mr *MockTxDatabaseMockRecorder) ID() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "ID", reflect.TypeOf((*MockTxDatabase)(nil).ID))
}

// IsReadOnly mocks base method
func (_m *MockTxDatabase) IsReadOnly() bool {
	ret := _m.ctrl.Call(_m, "IsReadOnly")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsReadOnly indicates an expected call of IsReadOnly
func (_mr *MockTxDatabaseMockRecorder) IsReadOnly() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "IsReadOnly", reflect.TypeOf((*MockTxDatabase)(nil).IsReadOnly))
}

// Query mocks base method
func (_m *MockTxDatabase) Query(_param0 *skydb.Query, _param1 *skydb.AccessControlOptions) (*skydb.Rows, error) {
	ret := _m.ctrl.Call(_m, "Query", _param0, _param1)
	ret0, _ := ret[0].(*skydb.Rows)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query
func (_mr *MockTxDatabaseMockRecorder) Query(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Query", reflect.TypeOf((*MockTxDatabase)(nil).Query), arg0, arg1)
}

// QueryCount mocks base method
func (_m *MockTxDatabase) QueryCount(_param0 *skydb.Query, _param1 *skydb.AccessControlOptions) (uint64, error) {
	ret := _m.ctrl.Call(_m, "QueryCount", _param0, _param1)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryCount indicates an expected call of QueryCount
func (_mr *MockTxDatabaseMockRecorder) QueryCount(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "QueryCount", reflect.TypeOf((*MockTxDatabase)(nil).QueryCount), arg0, arg1)
}

// RemoteColumnTypes mocks base method
func (_m *MockTxDatabase) RemoteColumnTypes(_param0 string) (skydb.RecordSchema, error) {
	ret := _m.ctrl.Call(_m, "RemoteColumnTypes", _param0)
	ret0, _ := ret[0].(skydb.RecordSchema)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoteColumnTypes indicates an expected call of RemoteColumnTypes
func (_mr *MockTxDatabaseMockRecorder) RemoteColumnTypes(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "RemoteColumnTypes", reflect.TypeOf((*MockTxDatabase)(nil).RemoteColumnTypes), arg0)
}

// RenameSchema mocks base method
func (_m *MockTxDatabase) RenameSchema(_param0 string, _param1 string, _param2 string) error {
	ret := _m.ctrl.Call(_m, "RenameSchema", _param0, _param1, _param2)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameSchema indicates an expected call of RenameSchema
func (_mr *MockTxDatabaseMockRecorder) RenameSchema(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "RenameSchema", reflect.TypeOf((*MockTxDatabase)(nil).RenameSchema), arg0, arg1, arg2)
}

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

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

// Save mocks base method
func (_m *MockTxDatabase) Save(_param0 *skydb.Record) error {
	ret := _m.ctrl.Call(_m, "Save", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Save indicates an expected call of Save
func (_mr *MockTxDatabaseMockRecorder) Save(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Save", reflect.TypeOf((*MockTxDatabase)(nil).Save), arg0)
}

// SaveIndex mocks base method
func (_m *MockTxDatabase) SaveIndex(_param0 string, _param1 string, _param2 skydb.Index) error {
	ret := _m.ctrl.Call(_m, "SaveIndex", _param0, _param1, _param2)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveIndex indicates an expected call of SaveIndex
func (_mr *MockTxDatabaseMockRecorder) SaveIndex(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "SaveIndex", reflect.TypeOf((*MockTxDatabase)(nil).SaveIndex), arg0, arg1, arg2)
}

// SaveSubscription mocks base method
func (_m *MockTxDatabase) SaveSubscription(_param0 *skydb.Subscription) error {
	ret := _m.ctrl.Call(_m, "SaveSubscription", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveSubscription indicates an expected call of SaveSubscription
func (_mr *MockTxDatabaseMockRecorder) SaveSubscription(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "SaveSubscription", reflect.TypeOf((*MockTxDatabase)(nil).SaveSubscription), arg0)
}

// TableName mocks base method
func (_m *MockTxDatabase) TableName(_param0 string) string {
	ret := _m.ctrl.Call(_m, "TableName", _param0)
	ret0, _ := ret[0].(string)
	return ret0
}

// TableName indicates an expected call of TableName
func (_mr *MockTxDatabaseMockRecorder) TableName(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "TableName", reflect.TypeOf((*MockTxDatabase)(nil).TableName), arg0)
}

// UserRecordType mocks base method
func (_m *MockTxDatabase) UserRecordType() string {
	ret := _m.ctrl.Call(_m, "UserRecordType")
	ret0, _ := ret[0].(string)
	return ret0
}

// UserRecordType indicates an expected call of UserRecordType
func (_mr *MockTxDatabaseMockRecorder) UserRecordType() *gomock.Call {
	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "UserRecordType", reflect.TypeOf((*MockTxDatabase)(nil).UserRecordType))
}