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 }