github.com/enbility/spine-go@v0.7.0/mocks/OperationsInterface.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  // OperationsInterface is an autogenerated mock type for the OperationsInterface type
    11  type OperationsInterface struct {
    12  	mock.Mock
    13  }
    14  
    15  type OperationsInterface_Expecter struct {
    16  	mock *mock.Mock
    17  }
    18  
    19  func (_m *OperationsInterface) EXPECT() *OperationsInterface_Expecter {
    20  	return &OperationsInterface_Expecter{mock: &_m.Mock}
    21  }
    22  
    23  // Information provides a mock function with given fields:
    24  func (_m *OperationsInterface) Information() *model.PossibleOperationsType {
    25  	ret := _m.Called()
    26  
    27  	if len(ret) == 0 {
    28  		panic("no return value specified for Information")
    29  	}
    30  
    31  	var r0 *model.PossibleOperationsType
    32  	if rf, ok := ret.Get(0).(func() *model.PossibleOperationsType); ok {
    33  		r0 = rf()
    34  	} else {
    35  		if ret.Get(0) != nil {
    36  			r0 = ret.Get(0).(*model.PossibleOperationsType)
    37  		}
    38  	}
    39  
    40  	return r0
    41  }
    42  
    43  // OperationsInterface_Information_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Information'
    44  type OperationsInterface_Information_Call struct {
    45  	*mock.Call
    46  }
    47  
    48  // Information is a helper method to define mock.On call
    49  func (_e *OperationsInterface_Expecter) Information() *OperationsInterface_Information_Call {
    50  	return &OperationsInterface_Information_Call{Call: _e.mock.On("Information")}
    51  }
    52  
    53  func (_c *OperationsInterface_Information_Call) Run(run func()) *OperationsInterface_Information_Call {
    54  	_c.Call.Run(func(args mock.Arguments) {
    55  		run()
    56  	})
    57  	return _c
    58  }
    59  
    60  func (_c *OperationsInterface_Information_Call) Return(_a0 *model.PossibleOperationsType) *OperationsInterface_Information_Call {
    61  	_c.Call.Return(_a0)
    62  	return _c
    63  }
    64  
    65  func (_c *OperationsInterface_Information_Call) RunAndReturn(run func() *model.PossibleOperationsType) *OperationsInterface_Information_Call {
    66  	_c.Call.Return(run)
    67  	return _c
    68  }
    69  
    70  // Read provides a mock function with given fields:
    71  func (_m *OperationsInterface) Read() bool {
    72  	ret := _m.Called()
    73  
    74  	if len(ret) == 0 {
    75  		panic("no return value specified for Read")
    76  	}
    77  
    78  	var r0 bool
    79  	if rf, ok := ret.Get(0).(func() bool); ok {
    80  		r0 = rf()
    81  	} else {
    82  		r0 = ret.Get(0).(bool)
    83  	}
    84  
    85  	return r0
    86  }
    87  
    88  // OperationsInterface_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
    89  type OperationsInterface_Read_Call struct {
    90  	*mock.Call
    91  }
    92  
    93  // Read is a helper method to define mock.On call
    94  func (_e *OperationsInterface_Expecter) Read() *OperationsInterface_Read_Call {
    95  	return &OperationsInterface_Read_Call{Call: _e.mock.On("Read")}
    96  }
    97  
    98  func (_c *OperationsInterface_Read_Call) Run(run func()) *OperationsInterface_Read_Call {
    99  	_c.Call.Run(func(args mock.Arguments) {
   100  		run()
   101  	})
   102  	return _c
   103  }
   104  
   105  func (_c *OperationsInterface_Read_Call) Return(_a0 bool) *OperationsInterface_Read_Call {
   106  	_c.Call.Return(_a0)
   107  	return _c
   108  }
   109  
   110  func (_c *OperationsInterface_Read_Call) RunAndReturn(run func() bool) *OperationsInterface_Read_Call {
   111  	_c.Call.Return(run)
   112  	return _c
   113  }
   114  
   115  // ReadPartial provides a mock function with given fields:
   116  func (_m *OperationsInterface) ReadPartial() bool {
   117  	ret := _m.Called()
   118  
   119  	if len(ret) == 0 {
   120  		panic("no return value specified for ReadPartial")
   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  // OperationsInterface_ReadPartial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadPartial'
   134  type OperationsInterface_ReadPartial_Call struct {
   135  	*mock.Call
   136  }
   137  
   138  // ReadPartial is a helper method to define mock.On call
   139  func (_e *OperationsInterface_Expecter) ReadPartial() *OperationsInterface_ReadPartial_Call {
   140  	return &OperationsInterface_ReadPartial_Call{Call: _e.mock.On("ReadPartial")}
   141  }
   142  
   143  func (_c *OperationsInterface_ReadPartial_Call) Run(run func()) *OperationsInterface_ReadPartial_Call {
   144  	_c.Call.Run(func(args mock.Arguments) {
   145  		run()
   146  	})
   147  	return _c
   148  }
   149  
   150  func (_c *OperationsInterface_ReadPartial_Call) Return(_a0 bool) *OperationsInterface_ReadPartial_Call {
   151  	_c.Call.Return(_a0)
   152  	return _c
   153  }
   154  
   155  func (_c *OperationsInterface_ReadPartial_Call) RunAndReturn(run func() bool) *OperationsInterface_ReadPartial_Call {
   156  	_c.Call.Return(run)
   157  	return _c
   158  }
   159  
   160  // String provides a mock function with given fields:
   161  func (_m *OperationsInterface) String() string {
   162  	ret := _m.Called()
   163  
   164  	if len(ret) == 0 {
   165  		panic("no return value specified for String")
   166  	}
   167  
   168  	var r0 string
   169  	if rf, ok := ret.Get(0).(func() string); ok {
   170  		r0 = rf()
   171  	} else {
   172  		r0 = ret.Get(0).(string)
   173  	}
   174  
   175  	return r0
   176  }
   177  
   178  // OperationsInterface_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
   179  type OperationsInterface_String_Call struct {
   180  	*mock.Call
   181  }
   182  
   183  // String is a helper method to define mock.On call
   184  func (_e *OperationsInterface_Expecter) String() *OperationsInterface_String_Call {
   185  	return &OperationsInterface_String_Call{Call: _e.mock.On("String")}
   186  }
   187  
   188  func (_c *OperationsInterface_String_Call) Run(run func()) *OperationsInterface_String_Call {
   189  	_c.Call.Run(func(args mock.Arguments) {
   190  		run()
   191  	})
   192  	return _c
   193  }
   194  
   195  func (_c *OperationsInterface_String_Call) Return(_a0 string) *OperationsInterface_String_Call {
   196  	_c.Call.Return(_a0)
   197  	return _c
   198  }
   199  
   200  func (_c *OperationsInterface_String_Call) RunAndReturn(run func() string) *OperationsInterface_String_Call {
   201  	_c.Call.Return(run)
   202  	return _c
   203  }
   204  
   205  // Write provides a mock function with given fields:
   206  func (_m *OperationsInterface) Write() bool {
   207  	ret := _m.Called()
   208  
   209  	if len(ret) == 0 {
   210  		panic("no return value specified for Write")
   211  	}
   212  
   213  	var r0 bool
   214  	if rf, ok := ret.Get(0).(func() bool); ok {
   215  		r0 = rf()
   216  	} else {
   217  		r0 = ret.Get(0).(bool)
   218  	}
   219  
   220  	return r0
   221  }
   222  
   223  // OperationsInterface_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
   224  type OperationsInterface_Write_Call struct {
   225  	*mock.Call
   226  }
   227  
   228  // Write is a helper method to define mock.On call
   229  func (_e *OperationsInterface_Expecter) Write() *OperationsInterface_Write_Call {
   230  	return &OperationsInterface_Write_Call{Call: _e.mock.On("Write")}
   231  }
   232  
   233  func (_c *OperationsInterface_Write_Call) Run(run func()) *OperationsInterface_Write_Call {
   234  	_c.Call.Run(func(args mock.Arguments) {
   235  		run()
   236  	})
   237  	return _c
   238  }
   239  
   240  func (_c *OperationsInterface_Write_Call) Return(_a0 bool) *OperationsInterface_Write_Call {
   241  	_c.Call.Return(_a0)
   242  	return _c
   243  }
   244  
   245  func (_c *OperationsInterface_Write_Call) RunAndReturn(run func() bool) *OperationsInterface_Write_Call {
   246  	_c.Call.Return(run)
   247  	return _c
   248  }
   249  
   250  // WritePartial provides a mock function with given fields:
   251  func (_m *OperationsInterface) WritePartial() bool {
   252  	ret := _m.Called()
   253  
   254  	if len(ret) == 0 {
   255  		panic("no return value specified for WritePartial")
   256  	}
   257  
   258  	var r0 bool
   259  	if rf, ok := ret.Get(0).(func() bool); ok {
   260  		r0 = rf()
   261  	} else {
   262  		r0 = ret.Get(0).(bool)
   263  	}
   264  
   265  	return r0
   266  }
   267  
   268  // OperationsInterface_WritePartial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WritePartial'
   269  type OperationsInterface_WritePartial_Call struct {
   270  	*mock.Call
   271  }
   272  
   273  // WritePartial is a helper method to define mock.On call
   274  func (_e *OperationsInterface_Expecter) WritePartial() *OperationsInterface_WritePartial_Call {
   275  	return &OperationsInterface_WritePartial_Call{Call: _e.mock.On("WritePartial")}
   276  }
   277  
   278  func (_c *OperationsInterface_WritePartial_Call) Run(run func()) *OperationsInterface_WritePartial_Call {
   279  	_c.Call.Run(func(args mock.Arguments) {
   280  		run()
   281  	})
   282  	return _c
   283  }
   284  
   285  func (_c *OperationsInterface_WritePartial_Call) Return(_a0 bool) *OperationsInterface_WritePartial_Call {
   286  	_c.Call.Return(_a0)
   287  	return _c
   288  }
   289  
   290  func (_c *OperationsInterface_WritePartial_Call) RunAndReturn(run func() bool) *OperationsInterface_WritePartial_Call {
   291  	_c.Call.Return(run)
   292  	return _c
   293  }
   294  
   295  // NewOperationsInterface creates a new instance of OperationsInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
   296  // The first argument is typically a *testing.T value.
   297  func NewOperationsInterface(t interface {
   298  	mock.TestingT
   299  	Cleanup(func())
   300  }) *OperationsInterface {
   301  	mock := &OperationsInterface{}
   302  	mock.Mock.Test(t)
   303  
   304  	t.Cleanup(func() { mock.AssertExpectations(t) })
   305  
   306  	return mock
   307  }