services.go

// Code generated by mockery v2.32.4. DO NOT EDIT.

package mocks

import (
	context "context"

	corev1 "k8s.io/api/core/v1"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	mock "github.com/stretchr/testify/mock"

	rest "k8s.io/client-go/rest"

	types "k8s.io/apimachinery/pkg/types"

	v1 "k8s.io/client-go/applyconfigurations/core/v1"

	watch "k8s.io/apimachinery/pkg/watch"
)

// Services is an autogenerated mock type for the Services type
type Services struct {
	mock.Mock
}

type Services_Expecter struct {
	mock *mock.Mock
}

func (_m *Services) EXPECT() *Services_Expecter {
	return &Services_Expecter{mock: &_m.Mock}
}

// Apply provides a mock function with given fields: ctx, service, opts
func (_m *Services) Apply(ctx context.Context, service *v1.ServiceApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Service, error) {
	ret := _m.Called(ctx, service, opts)

	var r0 *corev1.Service
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) (*corev1.Service, error)); ok {
		return rf(ctx, service, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) *corev1.Service); ok {
		r0 = rf(ctx, service, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1.Service)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) error); ok {
		r1 = rf(ctx, service, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_Apply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Apply'
type Services_Apply_Call struct {
	*mock.Call
}

// Apply is a helper method to define mock.On call
//   - ctx context.Context
//   - service *v1.ServiceApplyConfiguration
//   - opts metav1.ApplyOptions
func (_e *Services_Expecter) Apply(ctx interface{}, service interface{}, opts interface{}) *Services_Apply_Call {
	return &Services_Apply_Call{Call: _e.mock.On("Apply", ctx, service, opts)}
}

func (_c *Services_Apply_Call) Run(run func(ctx context.Context, service *v1.ServiceApplyConfiguration, opts metav1.ApplyOptions)) *Services_Apply_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*v1.ServiceApplyConfiguration), args[2].(metav1.ApplyOptions))
	})
	return _c
}

func (_c *Services_Apply_Call) Return(result *corev1.Service, err error) *Services_Apply_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *Services_Apply_Call) RunAndReturn(run func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) (*corev1.Service, error)) *Services_Apply_Call {
	_c.Call.Return(run)
	return _c
}

// ApplyStatus provides a mock function with given fields: ctx, service, opts
func (_m *Services) ApplyStatus(ctx context.Context, service *v1.ServiceApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Service, error) {
	ret := _m.Called(ctx, service, opts)

	var r0 *corev1.Service
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) (*corev1.Service, error)); ok {
		return rf(ctx, service, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) *corev1.Service); ok {
		r0 = rf(ctx, service, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1.Service)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) error); ok {
		r1 = rf(ctx, service, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_ApplyStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyStatus'
type Services_ApplyStatus_Call struct {
	*mock.Call
}

// ApplyStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - service *v1.ServiceApplyConfiguration
//   - opts metav1.ApplyOptions
func (_e *Services_Expecter) ApplyStatus(ctx interface{}, service interface{}, opts interface{}) *Services_ApplyStatus_Call {
	return &Services_ApplyStatus_Call{Call: _e.mock.On("ApplyStatus", ctx, service, opts)}
}

func (_c *Services_ApplyStatus_Call) Run(run func(ctx context.Context, service *v1.ServiceApplyConfiguration, opts metav1.ApplyOptions)) *Services_ApplyStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*v1.ServiceApplyConfiguration), args[2].(metav1.ApplyOptions))
	})
	return _c
}

func (_c *Services_ApplyStatus_Call) Return(result *corev1.Service, err error) *Services_ApplyStatus_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *Services_ApplyStatus_Call) RunAndReturn(run func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) (*corev1.Service, error)) *Services_ApplyStatus_Call {
	_c.Call.Return(run)
	return _c
}

// Create provides a mock function with given fields: ctx, service, opts
func (_m *Services) Create(ctx context.Context, service *corev1.Service, opts metav1.CreateOptions) (*corev1.Service, error) {
	ret := _m.Called(ctx, service, opts)

	var r0 *corev1.Service
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.CreateOptions) (*corev1.Service, error)); ok {
		return rf(ctx, service, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.CreateOptions) *corev1.Service); ok {
		r0 = rf(ctx, service, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1.Service)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *corev1.Service, metav1.CreateOptions) error); ok {
		r1 = rf(ctx, service, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
type Services_Create_Call struct {
	*mock.Call
}

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - service *corev1.Service
//   - opts metav1.CreateOptions
func (_e *Services_Expecter) Create(ctx interface{}, service interface{}, opts interface{}) *Services_Create_Call {
	return &Services_Create_Call{Call: _e.mock.On("Create", ctx, service, opts)}
}

func (_c *Services_Create_Call) Run(run func(ctx context.Context, service *corev1.Service, opts metav1.CreateOptions)) *Services_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*corev1.Service), args[2].(metav1.CreateOptions))
	})
	return _c
}

func (_c *Services_Create_Call) Return(_a0 *corev1.Service, _a1 error) *Services_Create_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Services_Create_Call) RunAndReturn(run func(context.Context, *corev1.Service, metav1.CreateOptions) (*corev1.Service, error)) *Services_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: ctx, name, opts
func (_m *Services) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
	ret := _m.Called(ctx, name, opts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, metav1.DeleteOptions) error); ok {
		r0 = rf(ctx, name, opts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// Services_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
type Services_Delete_Call struct {
	*mock.Call
}

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - opts metav1.DeleteOptions
func (_e *Services_Expecter) Delete(ctx interface{}, name interface{}, opts interface{}) *Services_Delete_Call {
	return &Services_Delete_Call{Call: _e.mock.On("Delete", ctx, name, opts)}
}

func (_c *Services_Delete_Call) Run(run func(ctx context.Context, name string, opts metav1.DeleteOptions)) *Services_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(metav1.DeleteOptions))
	})
	return _c
}

func (_c *Services_Delete_Call) Return(_a0 error) *Services_Delete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Services_Delete_Call) RunAndReturn(run func(context.Context, string, metav1.DeleteOptions) error) *Services_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function with given fields: ctx, name, opts
func (_m *Services) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.Service, error) {
	ret := _m.Called(ctx, name, opts)

	var r0 *corev1.Service
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) (*corev1.Service, error)); ok {
		return rf(ctx, name, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.Service); ok {
		r0 = rf(ctx, name, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1.Service)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, metav1.GetOptions) error); ok {
		r1 = rf(ctx, name, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
type Services_Get_Call struct {
	*mock.Call
}

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - opts metav1.GetOptions
func (_e *Services_Expecter) Get(ctx interface{}, name interface{}, opts interface{}) *Services_Get_Call {
	return &Services_Get_Call{Call: _e.mock.On("Get", ctx, name, opts)}
}

func (_c *Services_Get_Call) Run(run func(ctx context.Context, name string, opts metav1.GetOptions)) *Services_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(metav1.GetOptions))
	})
	return _c
}

func (_c *Services_Get_Call) Return(_a0 *corev1.Service, _a1 error) *Services_Get_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Services_Get_Call) RunAndReturn(run func(context.Context, string, metav1.GetOptions) (*corev1.Service, error)) *Services_Get_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function with given fields: ctx, opts
func (_m *Services) List(ctx context.Context, opts metav1.ListOptions) (*corev1.ServiceList, error) {
	ret := _m.Called(ctx, opts)

	var r0 *corev1.ServiceList
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) (*corev1.ServiceList, error)); ok {
		return rf(ctx, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.ServiceList); ok {
		r0 = rf(ctx, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1.ServiceList)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok {
		r1 = rf(ctx, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
type Services_List_Call struct {
	*mock.Call
}

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - opts metav1.ListOptions
func (_e *Services_Expecter) List(ctx interface{}, opts interface{}) *Services_List_Call {
	return &Services_List_Call{Call: _e.mock.On("List", ctx, opts)}
}

func (_c *Services_List_Call) Run(run func(ctx context.Context, opts metav1.ListOptions)) *Services_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(metav1.ListOptions))
	})
	return _c
}

func (_c *Services_List_Call) Return(_a0 *corev1.ServiceList, _a1 error) *Services_List_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Services_List_Call) RunAndReturn(run func(context.Context, metav1.ListOptions) (*corev1.ServiceList, error)) *Services_List_Call {
	_c.Call.Return(run)
	return _c
}

// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources
func (_m *Services) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.Service, error) {
	_va := make([]interface{}, len(subresources))
	for _i := range subresources {
		_va[_i] = subresources[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, name, pt, data, opts)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *corev1.Service
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) (*corev1.Service, error)); ok {
		return rf(ctx, name, pt, data, opts, subresources...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.Service); ok {
		r0 = rf(ctx, name, pt, data, opts, subresources...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1.Service)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) error); ok {
		r1 = rf(ctx, name, pt, data, opts, subresources...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_Patch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Patch'
type Services_Patch_Call struct {
	*mock.Call
}

// Patch is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - pt types.PatchType
//   - data []byte
//   - opts metav1.PatchOptions
//   - subresources ...string
func (_e *Services_Expecter) Patch(ctx interface{}, name interface{}, pt interface{}, data interface{}, opts interface{}, subresources ...interface{}) *Services_Patch_Call {
	return &Services_Patch_Call{Call: _e.mock.On("Patch",
		append([]interface{}{ctx, name, pt, data, opts}, subresources...)...)}
}

func (_c *Services_Patch_Call) Run(run func(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string)) *Services_Patch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-5)
		for i, a := range args[5:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(types.PatchType), args[3].([]byte), args[4].(metav1.PatchOptions), variadicArgs...)
	})
	return _c
}

func (_c *Services_Patch_Call) Return(result *corev1.Service, err error) *Services_Patch_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *Services_Patch_Call) RunAndReturn(run func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) (*corev1.Service, error)) *Services_Patch_Call {
	_c.Call.Return(run)
	return _c
}

// ProxyGet provides a mock function with given fields: scheme, name, port, path, params
func (_m *Services) ProxyGet(scheme string, name string, port string, path string, params map[string]string) rest.ResponseWrapper {
	ret := _m.Called(scheme, name, port, path, params)

	var r0 rest.ResponseWrapper
	if rf, ok := ret.Get(0).(func(string, string, string, string, map[string]string) rest.ResponseWrapper); ok {
		r0 = rf(scheme, name, port, path, params)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(rest.ResponseWrapper)
		}
	}

	return r0
}

// Services_ProxyGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProxyGet'
type Services_ProxyGet_Call struct {
	*mock.Call
}

// ProxyGet is a helper method to define mock.On call
//   - scheme string
//   - name string
//   - port string
//   - path string
//   - params map[string]string
func (_e *Services_Expecter) ProxyGet(scheme interface{}, name interface{}, port interface{}, path interface{}, params interface{}) *Services_ProxyGet_Call {
	return &Services_ProxyGet_Call{Call: _e.mock.On("ProxyGet", scheme, name, port, path, params)}
}

func (_c *Services_ProxyGet_Call) Run(run func(scheme string, name string, port string, path string, params map[string]string)) *Services_ProxyGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(map[string]string))
	})
	return _c
}

func (_c *Services_ProxyGet_Call) Return(_a0 rest.ResponseWrapper) *Services_ProxyGet_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Services_ProxyGet_Call) RunAndReturn(run func(string, string, string, string, map[string]string) rest.ResponseWrapper) *Services_ProxyGet_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function with given fields: ctx, service, opts
func (_m *Services) Update(ctx context.Context, service *corev1.Service, opts metav1.UpdateOptions) (*corev1.Service, error) {
	ret := _m.Called(ctx, service, opts)

	var r0 *corev1.Service
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.UpdateOptions) (*corev1.Service, error)); ok {
		return rf(ctx, service, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.UpdateOptions) *corev1.Service); ok {
		r0 = rf(ctx, service, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1.Service)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *corev1.Service, metav1.UpdateOptions) error); ok {
		r1 = rf(ctx, service, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
type Services_Update_Call struct {
	*mock.Call
}

// Update is a helper method to define mock.On call
//   - ctx context.Context
//   - service *corev1.Service
//   - opts metav1.UpdateOptions
func (_e *Services_Expecter) Update(ctx interface{}, service interface{}, opts interface{}) *Services_Update_Call {
	return &Services_Update_Call{Call: _e.mock.On("Update", ctx, service, opts)}
}

func (_c *Services_Update_Call) Run(run func(ctx context.Context, service *corev1.Service, opts metav1.UpdateOptions)) *Services_Update_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*corev1.Service), args[2].(metav1.UpdateOptions))
	})
	return _c
}

func (_c *Services_Update_Call) Return(_a0 *corev1.Service, _a1 error) *Services_Update_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Services_Update_Call) RunAndReturn(run func(context.Context, *corev1.Service, metav1.UpdateOptions) (*corev1.Service, error)) *Services_Update_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStatus provides a mock function with given fields: ctx, service, opts
func (_m *Services) UpdateStatus(ctx context.Context, service *corev1.Service, opts metav1.UpdateOptions) (*corev1.Service, error) {
	ret := _m.Called(ctx, service, opts)

	var r0 *corev1.Service
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.UpdateOptions) (*corev1.Service, error)); ok {
		return rf(ctx, service, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.UpdateOptions) *corev1.Service); ok {
		r0 = rf(ctx, service, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1.Service)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *corev1.Service, metav1.UpdateOptions) error); ok {
		r1 = rf(ctx, service, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_UpdateStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStatus'
type Services_UpdateStatus_Call struct {
	*mock.Call
}

// UpdateStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - service *corev1.Service
//   - opts metav1.UpdateOptions
func (_e *Services_Expecter) UpdateStatus(ctx interface{}, service interface{}, opts interface{}) *Services_UpdateStatus_Call {
	return &Services_UpdateStatus_Call{Call: _e.mock.On("UpdateStatus", ctx, service, opts)}
}

func (_c *Services_UpdateStatus_Call) Run(run func(ctx context.Context, service *corev1.Service, opts metav1.UpdateOptions)) *Services_UpdateStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*corev1.Service), args[2].(metav1.UpdateOptions))
	})
	return _c
}

func (_c *Services_UpdateStatus_Call) Return(_a0 *corev1.Service, _a1 error) *Services_UpdateStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Services_UpdateStatus_Call) RunAndReturn(run func(context.Context, *corev1.Service, metav1.UpdateOptions) (*corev1.Service, error)) *Services_UpdateStatus_Call {
	_c.Call.Return(run)
	return _c
}

// Watch provides a mock function with given fields: ctx, opts
func (_m *Services) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
	ret := _m.Called(ctx, opts)

	var r0 watch.Interface
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) (watch.Interface, error)); ok {
		return rf(ctx, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) watch.Interface); ok {
		r0 = rf(ctx, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(watch.Interface)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok {
		r1 = rf(ctx, opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Services_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
type Services_Watch_Call struct {
	*mock.Call
}

// Watch is a helper method to define mock.On call
//   - ctx context.Context
//   - opts metav1.ListOptions
func (_e *Services_Expecter) Watch(ctx interface{}, opts interface{}) *Services_Watch_Call {
	return &Services_Watch_Call{Call: _e.mock.On("Watch", ctx, opts)}
}

func (_c *Services_Watch_Call) Run(run func(ctx context.Context, opts metav1.ListOptions)) *Services_Watch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(metav1.ListOptions))
	})
	return _c
}

func (_c *Services_Watch_Call) Return(_a0 watch.Interface, _a1 error) *Services_Watch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Services_Watch_Call) RunAndReturn(run func(context.Context, metav1.ListOptions) (watch.Interface, error)) *Services_Watch_Call {
	_c.Call.Return(run)
	return _c
}

// NewServices creates a new instance of Services. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewServices(t interface {
	mock.TestingT
	Cleanup(func())
}) *Services {
	mock := &Services{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}