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  }