github.com/enbility/spine-go@v0.7.0/mocks/FeatureInterface.go (about) 1 // Code generated by mockery v2.45.0. DO NOT EDIT. 2 3 package mocks 4 5 import ( 6 api "github.com/enbility/spine-go/api" 7 mock "github.com/stretchr/testify/mock" 8 9 model "github.com/enbility/spine-go/model" 10 ) 11 12 // FeatureInterface is an autogenerated mock type for the FeatureInterface type 13 type FeatureInterface struct { 14 mock.Mock 15 } 16 17 type FeatureInterface_Expecter struct { 18 mock *mock.Mock 19 } 20 21 func (_m *FeatureInterface) EXPECT() *FeatureInterface_Expecter { 22 return &FeatureInterface_Expecter{mock: &_m.Mock} 23 } 24 25 // Address provides a mock function with given fields: 26 func (_m *FeatureInterface) Address() *model.FeatureAddressType { 27 ret := _m.Called() 28 29 if len(ret) == 0 { 30 panic("no return value specified for Address") 31 } 32 33 var r0 *model.FeatureAddressType 34 if rf, ok := ret.Get(0).(func() *model.FeatureAddressType); ok { 35 r0 = rf() 36 } else { 37 if ret.Get(0) != nil { 38 r0 = ret.Get(0).(*model.FeatureAddressType) 39 } 40 } 41 42 return r0 43 } 44 45 // FeatureInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address' 46 type FeatureInterface_Address_Call struct { 47 *mock.Call 48 } 49 50 // Address is a helper method to define mock.On call 51 func (_e *FeatureInterface_Expecter) Address() *FeatureInterface_Address_Call { 52 return &FeatureInterface_Address_Call{Call: _e.mock.On("Address")} 53 } 54 55 func (_c *FeatureInterface_Address_Call) Run(run func()) *FeatureInterface_Address_Call { 56 _c.Call.Run(func(args mock.Arguments) { 57 run() 58 }) 59 return _c 60 } 61 62 func (_c *FeatureInterface_Address_Call) Return(_a0 *model.FeatureAddressType) *FeatureInterface_Address_Call { 63 _c.Call.Return(_a0) 64 return _c 65 } 66 67 func (_c *FeatureInterface_Address_Call) RunAndReturn(run func() *model.FeatureAddressType) *FeatureInterface_Address_Call { 68 _c.Call.Return(run) 69 return _c 70 } 71 72 // Description provides a mock function with given fields: 73 func (_m *FeatureInterface) Description() *model.DescriptionType { 74 ret := _m.Called() 75 76 if len(ret) == 0 { 77 panic("no return value specified for Description") 78 } 79 80 var r0 *model.DescriptionType 81 if rf, ok := ret.Get(0).(func() *model.DescriptionType); ok { 82 r0 = rf() 83 } else { 84 if ret.Get(0) != nil { 85 r0 = ret.Get(0).(*model.DescriptionType) 86 } 87 } 88 89 return r0 90 } 91 92 // FeatureInterface_Description_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Description' 93 type FeatureInterface_Description_Call struct { 94 *mock.Call 95 } 96 97 // Description is a helper method to define mock.On call 98 func (_e *FeatureInterface_Expecter) Description() *FeatureInterface_Description_Call { 99 return &FeatureInterface_Description_Call{Call: _e.mock.On("Description")} 100 } 101 102 func (_c *FeatureInterface_Description_Call) Run(run func()) *FeatureInterface_Description_Call { 103 _c.Call.Run(func(args mock.Arguments) { 104 run() 105 }) 106 return _c 107 } 108 109 func (_c *FeatureInterface_Description_Call) Return(_a0 *model.DescriptionType) *FeatureInterface_Description_Call { 110 _c.Call.Return(_a0) 111 return _c 112 } 113 114 func (_c *FeatureInterface_Description_Call) RunAndReturn(run func() *model.DescriptionType) *FeatureInterface_Description_Call { 115 _c.Call.Return(run) 116 return _c 117 } 118 119 // Operations provides a mock function with given fields: 120 func (_m *FeatureInterface) Operations() map[model.FunctionType]api.OperationsInterface { 121 ret := _m.Called() 122 123 if len(ret) == 0 { 124 panic("no return value specified for Operations") 125 } 126 127 var r0 map[model.FunctionType]api.OperationsInterface 128 if rf, ok := ret.Get(0).(func() map[model.FunctionType]api.OperationsInterface); ok { 129 r0 = rf() 130 } else { 131 if ret.Get(0) != nil { 132 r0 = ret.Get(0).(map[model.FunctionType]api.OperationsInterface) 133 } 134 } 135 136 return r0 137 } 138 139 // FeatureInterface_Operations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Operations' 140 type FeatureInterface_Operations_Call struct { 141 *mock.Call 142 } 143 144 // Operations is a helper method to define mock.On call 145 func (_e *FeatureInterface_Expecter) Operations() *FeatureInterface_Operations_Call { 146 return &FeatureInterface_Operations_Call{Call: _e.mock.On("Operations")} 147 } 148 149 func (_c *FeatureInterface_Operations_Call) Run(run func()) *FeatureInterface_Operations_Call { 150 _c.Call.Run(func(args mock.Arguments) { 151 run() 152 }) 153 return _c 154 } 155 156 func (_c *FeatureInterface_Operations_Call) Return(_a0 map[model.FunctionType]api.OperationsInterface) *FeatureInterface_Operations_Call { 157 _c.Call.Return(_a0) 158 return _c 159 } 160 161 func (_c *FeatureInterface_Operations_Call) RunAndReturn(run func() map[model.FunctionType]api.OperationsInterface) *FeatureInterface_Operations_Call { 162 _c.Call.Return(run) 163 return _c 164 } 165 166 // Role provides a mock function with given fields: 167 func (_m *FeatureInterface) Role() model.RoleType { 168 ret := _m.Called() 169 170 if len(ret) == 0 { 171 panic("no return value specified for Role") 172 } 173 174 var r0 model.RoleType 175 if rf, ok := ret.Get(0).(func() model.RoleType); ok { 176 r0 = rf() 177 } else { 178 r0 = ret.Get(0).(model.RoleType) 179 } 180 181 return r0 182 } 183 184 // FeatureInterface_Role_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Role' 185 type FeatureInterface_Role_Call struct { 186 *mock.Call 187 } 188 189 // Role is a helper method to define mock.On call 190 func (_e *FeatureInterface_Expecter) Role() *FeatureInterface_Role_Call { 191 return &FeatureInterface_Role_Call{Call: _e.mock.On("Role")} 192 } 193 194 func (_c *FeatureInterface_Role_Call) Run(run func()) *FeatureInterface_Role_Call { 195 _c.Call.Run(func(args mock.Arguments) { 196 run() 197 }) 198 return _c 199 } 200 201 func (_c *FeatureInterface_Role_Call) Return(_a0 model.RoleType) *FeatureInterface_Role_Call { 202 _c.Call.Return(_a0) 203 return _c 204 } 205 206 func (_c *FeatureInterface_Role_Call) RunAndReturn(run func() model.RoleType) *FeatureInterface_Role_Call { 207 _c.Call.Return(run) 208 return _c 209 } 210 211 // SetDescription provides a mock function with given fields: desc 212 func (_m *FeatureInterface) SetDescription(desc *model.DescriptionType) { 213 _m.Called(desc) 214 } 215 216 // FeatureInterface_SetDescription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescription' 217 type FeatureInterface_SetDescription_Call struct { 218 *mock.Call 219 } 220 221 // SetDescription is a helper method to define mock.On call 222 // - desc *model.DescriptionType 223 func (_e *FeatureInterface_Expecter) SetDescription(desc interface{}) *FeatureInterface_SetDescription_Call { 224 return &FeatureInterface_SetDescription_Call{Call: _e.mock.On("SetDescription", desc)} 225 } 226 227 func (_c *FeatureInterface_SetDescription_Call) Run(run func(desc *model.DescriptionType)) *FeatureInterface_SetDescription_Call { 228 _c.Call.Run(func(args mock.Arguments) { 229 run(args[0].(*model.DescriptionType)) 230 }) 231 return _c 232 } 233 234 func (_c *FeatureInterface_SetDescription_Call) Return() *FeatureInterface_SetDescription_Call { 235 _c.Call.Return() 236 return _c 237 } 238 239 func (_c *FeatureInterface_SetDescription_Call) RunAndReturn(run func(*model.DescriptionType)) *FeatureInterface_SetDescription_Call { 240 _c.Call.Return(run) 241 return _c 242 } 243 244 // SetDescriptionString provides a mock function with given fields: s 245 func (_m *FeatureInterface) SetDescriptionString(s string) { 246 _m.Called(s) 247 } 248 249 // FeatureInterface_SetDescriptionString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescriptionString' 250 type FeatureInterface_SetDescriptionString_Call struct { 251 *mock.Call 252 } 253 254 // SetDescriptionString is a helper method to define mock.On call 255 // - s string 256 func (_e *FeatureInterface_Expecter) SetDescriptionString(s interface{}) *FeatureInterface_SetDescriptionString_Call { 257 return &FeatureInterface_SetDescriptionString_Call{Call: _e.mock.On("SetDescriptionString", s)} 258 } 259 260 func (_c *FeatureInterface_SetDescriptionString_Call) Run(run func(s string)) *FeatureInterface_SetDescriptionString_Call { 261 _c.Call.Run(func(args mock.Arguments) { 262 run(args[0].(string)) 263 }) 264 return _c 265 } 266 267 func (_c *FeatureInterface_SetDescriptionString_Call) Return() *FeatureInterface_SetDescriptionString_Call { 268 _c.Call.Return() 269 return _c 270 } 271 272 func (_c *FeatureInterface_SetDescriptionString_Call) RunAndReturn(run func(string)) *FeatureInterface_SetDescriptionString_Call { 273 _c.Call.Return(run) 274 return _c 275 } 276 277 // String provides a mock function with given fields: 278 func (_m *FeatureInterface) String() string { 279 ret := _m.Called() 280 281 if len(ret) == 0 { 282 panic("no return value specified for String") 283 } 284 285 var r0 string 286 if rf, ok := ret.Get(0).(func() string); ok { 287 r0 = rf() 288 } else { 289 r0 = ret.Get(0).(string) 290 } 291 292 return r0 293 } 294 295 // FeatureInterface_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' 296 type FeatureInterface_String_Call struct { 297 *mock.Call 298 } 299 300 // String is a helper method to define mock.On call 301 func (_e *FeatureInterface_Expecter) String() *FeatureInterface_String_Call { 302 return &FeatureInterface_String_Call{Call: _e.mock.On("String")} 303 } 304 305 func (_c *FeatureInterface_String_Call) Run(run func()) *FeatureInterface_String_Call { 306 _c.Call.Run(func(args mock.Arguments) { 307 run() 308 }) 309 return _c 310 } 311 312 func (_c *FeatureInterface_String_Call) Return(_a0 string) *FeatureInterface_String_Call { 313 _c.Call.Return(_a0) 314 return _c 315 } 316 317 func (_c *FeatureInterface_String_Call) RunAndReturn(run func() string) *FeatureInterface_String_Call { 318 _c.Call.Return(run) 319 return _c 320 } 321 322 // Type provides a mock function with given fields: 323 func (_m *FeatureInterface) Type() model.FeatureTypeType { 324 ret := _m.Called() 325 326 if len(ret) == 0 { 327 panic("no return value specified for Type") 328 } 329 330 var r0 model.FeatureTypeType 331 if rf, ok := ret.Get(0).(func() model.FeatureTypeType); ok { 332 r0 = rf() 333 } else { 334 r0 = ret.Get(0).(model.FeatureTypeType) 335 } 336 337 return r0 338 } 339 340 // FeatureInterface_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type' 341 type FeatureInterface_Type_Call struct { 342 *mock.Call 343 } 344 345 // Type is a helper method to define mock.On call 346 func (_e *FeatureInterface_Expecter) Type() *FeatureInterface_Type_Call { 347 return &FeatureInterface_Type_Call{Call: _e.mock.On("Type")} 348 } 349 350 func (_c *FeatureInterface_Type_Call) Run(run func()) *FeatureInterface_Type_Call { 351 _c.Call.Run(func(args mock.Arguments) { 352 run() 353 }) 354 return _c 355 } 356 357 func (_c *FeatureInterface_Type_Call) Return(_a0 model.FeatureTypeType) *FeatureInterface_Type_Call { 358 _c.Call.Return(_a0) 359 return _c 360 } 361 362 func (_c *FeatureInterface_Type_Call) RunAndReturn(run func() model.FeatureTypeType) *FeatureInterface_Type_Call { 363 _c.Call.Return(run) 364 return _c 365 } 366 367 // NewFeatureInterface creates a new instance of FeatureInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. 368 // The first argument is typically a *testing.T value. 369 func NewFeatureInterface(t interface { 370 mock.TestingT 371 Cleanup(func()) 372 }) *FeatureInterface { 373 mock := &FeatureInterface{} 374 mock.Mock.Test(t) 375 376 t.Cleanup(func() { mock.AssertExpectations(t) }) 377 378 return mock 379 }