github.com/enbility/spine-go@v0.7.0/mocks/FunctionDataInterface.go (about)

     1  // Code generated by mockery v2.45.0. DO NOT EDIT.
     2  
     3  package mocks
     4  
     5  import (
     6  	model "github.com/enbility/spine-go/model"
     7  	mock "github.com/stretchr/testify/mock"
     8  )
     9  
    10  // FunctionDataInterface is an autogenerated mock type for the FunctionDataInterface type
    11  type FunctionDataInterface struct {
    12  	mock.Mock
    13  }
    14  
    15  type FunctionDataInterface_Expecter struct {
    16  	mock *mock.Mock
    17  }
    18  
    19  func (_m *FunctionDataInterface) EXPECT() *FunctionDataInterface_Expecter {
    20  	return &FunctionDataInterface_Expecter{mock: &_m.Mock}
    21  }
    22  
    23  // DataCopyAny provides a mock function with given fields:
    24  func (_m *FunctionDataInterface) DataCopyAny() interface{} {
    25  	ret := _m.Called()
    26  
    27  	if len(ret) == 0 {
    28  		panic("no return value specified for DataCopyAny")
    29  	}
    30  
    31  	var r0 interface{}
    32  	if rf, ok := ret.Get(0).(func() interface{}); ok {
    33  		r0 = rf()
    34  	} else {
    35  		if ret.Get(0) != nil {
    36  			r0 = ret.Get(0).(interface{})
    37  		}
    38  	}
    39  
    40  	return r0
    41  }
    42  
    43  // FunctionDataInterface_DataCopyAny_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataCopyAny'
    44  type FunctionDataInterface_DataCopyAny_Call struct {
    45  	*mock.Call
    46  }
    47  
    48  // DataCopyAny is a helper method to define mock.On call
    49  func (_e *FunctionDataInterface_Expecter) DataCopyAny() *FunctionDataInterface_DataCopyAny_Call {
    50  	return &FunctionDataInterface_DataCopyAny_Call{Call: _e.mock.On("DataCopyAny")}
    51  }
    52  
    53  func (_c *FunctionDataInterface_DataCopyAny_Call) Run(run func()) *FunctionDataInterface_DataCopyAny_Call {
    54  	_c.Call.Run(func(args mock.Arguments) {
    55  		run()
    56  	})
    57  	return _c
    58  }
    59  
    60  func (_c *FunctionDataInterface_DataCopyAny_Call) Return(_a0 interface{}) *FunctionDataInterface_DataCopyAny_Call {
    61  	_c.Call.Return(_a0)
    62  	return _c
    63  }
    64  
    65  func (_c *FunctionDataInterface_DataCopyAny_Call) RunAndReturn(run func() interface{}) *FunctionDataInterface_DataCopyAny_Call {
    66  	_c.Call.Return(run)
    67  	return _c
    68  }
    69  
    70  // FunctionType provides a mock function with given fields:
    71  func (_m *FunctionDataInterface) FunctionType() model.FunctionType {
    72  	ret := _m.Called()
    73  
    74  	if len(ret) == 0 {
    75  		panic("no return value specified for FunctionType")
    76  	}
    77  
    78  	var r0 model.FunctionType
    79  	if rf, ok := ret.Get(0).(func() model.FunctionType); ok {
    80  		r0 = rf()
    81  	} else {
    82  		r0 = ret.Get(0).(model.FunctionType)
    83  	}
    84  
    85  	return r0
    86  }
    87  
    88  // FunctionDataInterface_FunctionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionType'
    89  type FunctionDataInterface_FunctionType_Call struct {
    90  	*mock.Call
    91  }
    92  
    93  // FunctionType is a helper method to define mock.On call
    94  func (_e *FunctionDataInterface_Expecter) FunctionType() *FunctionDataInterface_FunctionType_Call {
    95  	return &FunctionDataInterface_FunctionType_Call{Call: _e.mock.On("FunctionType")}
    96  }
    97  
    98  func (_c *FunctionDataInterface_FunctionType_Call) Run(run func()) *FunctionDataInterface_FunctionType_Call {
    99  	_c.Call.Run(func(args mock.Arguments) {
   100  		run()
   101  	})
   102  	return _c
   103  }
   104  
   105  func (_c *FunctionDataInterface_FunctionType_Call) Return(_a0 model.FunctionType) *FunctionDataInterface_FunctionType_Call {
   106  	_c.Call.Return(_a0)
   107  	return _c
   108  }
   109  
   110  func (_c *FunctionDataInterface_FunctionType_Call) RunAndReturn(run func() model.FunctionType) *FunctionDataInterface_FunctionType_Call {
   111  	_c.Call.Return(run)
   112  	return _c
   113  }
   114  
   115  // SupportsPartialWrite provides a mock function with given fields:
   116  func (_m *FunctionDataInterface) SupportsPartialWrite() bool {
   117  	ret := _m.Called()
   118  
   119  	if len(ret) == 0 {
   120  		panic("no return value specified for SupportsPartialWrite")
   121  	}
   122  
   123  	var r0 bool
   124  	if rf, ok := ret.Get(0).(func() bool); ok {
   125  		r0 = rf()
   126  	} else {
   127  		r0 = ret.Get(0).(bool)
   128  	}
   129  
   130  	return r0
   131  }
   132  
   133  // FunctionDataInterface_SupportsPartialWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SupportsPartialWrite'
   134  type FunctionDataInterface_SupportsPartialWrite_Call struct {
   135  	*mock.Call
   136  }
   137  
   138  // SupportsPartialWrite is a helper method to define mock.On call
   139  func (_e *FunctionDataInterface_Expecter) SupportsPartialWrite() *FunctionDataInterface_SupportsPartialWrite_Call {
   140  	return &FunctionDataInterface_SupportsPartialWrite_Call{Call: _e.mock.On("SupportsPartialWrite")}
   141  }
   142  
   143  func (_c *FunctionDataInterface_SupportsPartialWrite_Call) Run(run func()) *FunctionDataInterface_SupportsPartialWrite_Call {
   144  	_c.Call.Run(func(args mock.Arguments) {
   145  		run()
   146  	})
   147  	return _c
   148  }
   149  
   150  func (_c *FunctionDataInterface_SupportsPartialWrite_Call) Return(_a0 bool) *FunctionDataInterface_SupportsPartialWrite_Call {
   151  	_c.Call.Return(_a0)
   152  	return _c
   153  }
   154  
   155  func (_c *FunctionDataInterface_SupportsPartialWrite_Call) RunAndReturn(run func() bool) *FunctionDataInterface_SupportsPartialWrite_Call {
   156  	_c.Call.Return(run)
   157  	return _c
   158  }
   159  
   160  // UpdateDataAny provides a mock function with given fields: remoteWrite, persist, data, filterPartial, filterDelete
   161  func (_m *FunctionDataInterface) UpdateDataAny(remoteWrite bool, persist bool, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType) (interface{}, *model.ErrorType) {
   162  	ret := _m.Called(remoteWrite, persist, data, filterPartial, filterDelete)
   163  
   164  	if len(ret) == 0 {
   165  		panic("no return value specified for UpdateDataAny")
   166  	}
   167  
   168  	var r0 interface{}
   169  	var r1 *model.ErrorType
   170  	if rf, ok := ret.Get(0).(func(bool, bool, interface{}, *model.FilterType, *model.FilterType) (interface{}, *model.ErrorType)); ok {
   171  		return rf(remoteWrite, persist, data, filterPartial, filterDelete)
   172  	}
   173  	if rf, ok := ret.Get(0).(func(bool, bool, interface{}, *model.FilterType, *model.FilterType) interface{}); ok {
   174  		r0 = rf(remoteWrite, persist, data, filterPartial, filterDelete)
   175  	} else {
   176  		if ret.Get(0) != nil {
   177  			r0 = ret.Get(0).(interface{})
   178  		}
   179  	}
   180  
   181  	if rf, ok := ret.Get(1).(func(bool, bool, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType); ok {
   182  		r1 = rf(remoteWrite, persist, data, filterPartial, filterDelete)
   183  	} else {
   184  		if ret.Get(1) != nil {
   185  			r1 = ret.Get(1).(*model.ErrorType)
   186  		}
   187  	}
   188  
   189  	return r0, r1
   190  }
   191  
   192  // FunctionDataInterface_UpdateDataAny_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataAny'
   193  type FunctionDataInterface_UpdateDataAny_Call struct {
   194  	*mock.Call
   195  }
   196  
   197  // UpdateDataAny is a helper method to define mock.On call
   198  //   - remoteWrite bool
   199  //   - persist bool
   200  //   - data interface{}
   201  //   - filterPartial *model.FilterType
   202  //   - filterDelete *model.FilterType
   203  func (_e *FunctionDataInterface_Expecter) UpdateDataAny(remoteWrite interface{}, persist interface{}, data interface{}, filterPartial interface{}, filterDelete interface{}) *FunctionDataInterface_UpdateDataAny_Call {
   204  	return &FunctionDataInterface_UpdateDataAny_Call{Call: _e.mock.On("UpdateDataAny", remoteWrite, persist, data, filterPartial, filterDelete)}
   205  }
   206  
   207  func (_c *FunctionDataInterface_UpdateDataAny_Call) Run(run func(remoteWrite bool, persist bool, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType)) *FunctionDataInterface_UpdateDataAny_Call {
   208  	_c.Call.Run(func(args mock.Arguments) {
   209  		run(args[0].(bool), args[1].(bool), args[2].(interface{}), args[3].(*model.FilterType), args[4].(*model.FilterType))
   210  	})
   211  	return _c
   212  }
   213  
   214  func (_c *FunctionDataInterface_UpdateDataAny_Call) Return(_a0 interface{}, _a1 *model.ErrorType) *FunctionDataInterface_UpdateDataAny_Call {
   215  	_c.Call.Return(_a0, _a1)
   216  	return _c
   217  }
   218  
   219  func (_c *FunctionDataInterface_UpdateDataAny_Call) RunAndReturn(run func(bool, bool, interface{}, *model.FilterType, *model.FilterType) (interface{}, *model.ErrorType)) *FunctionDataInterface_UpdateDataAny_Call {
   220  	_c.Call.Return(run)
   221  	return _c
   222  }
   223  
   224  // NewFunctionDataInterface creates a new instance of FunctionDataInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
   225  // The first argument is typically a *testing.T value.
   226  func NewFunctionDataInterface(t interface {
   227  	mock.TestingT
   228  	Cleanup(func())
   229  }) *FunctionDataInterface {
   230  	mock := &FunctionDataInterface{}
   231  	mock.Mock.Test(t)
   232  
   233  	t.Cleanup(func() { mock.AssertExpectations(t) })
   234  
   235  	return mock
   236  }