go/k8s/mocks/CoreV1Interface.go

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

package mocks

import (
	mock "github.com/stretchr/testify/mock"
	rest "k8s.io/client-go/rest"

	v1 "k8s.io/client-go/kubernetes/typed/core/v1"
)

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

type CoreV1Interface_Expecter struct {
	mock *mock.Mock
}

func (_m *CoreV1Interface) EXPECT() *CoreV1Interface_Expecter {
	return &CoreV1Interface_Expecter{mock: &_m.Mock}
}

// ComponentStatuses provides a mock function with given fields:
func (_m *CoreV1Interface) ComponentStatuses() v1.ComponentStatusInterface {
	ret := _m.Called()

	var r0 v1.ComponentStatusInterface
	if rf, ok := ret.Get(0).(func() v1.ComponentStatusInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.ComponentStatusInterface)
		}
	}

	return r0
}

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

// ComponentStatuses is a helper method to define mock.On call
func (_e *CoreV1Interface_Expecter) ComponentStatuses() *CoreV1Interface_ComponentStatuses_Call {
	return &CoreV1Interface_ComponentStatuses_Call{Call: _e.mock.On("ComponentStatuses")}
}

func (_c *CoreV1Interface_ComponentStatuses_Call) Run(run func()) *CoreV1Interface_ComponentStatuses_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *CoreV1Interface_ComponentStatuses_Call) Return(_a0 v1.ComponentStatusInterface) *CoreV1Interface_ComponentStatuses_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_ComponentStatuses_Call) RunAndReturn(run func() v1.ComponentStatusInterface) *CoreV1Interface_ComponentStatuses_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigMaps provides a mock function with given fields: namespace
func (_m *CoreV1Interface) ConfigMaps(namespace string) v1.ConfigMapInterface {
	ret := _m.Called(namespace)

	var r0 v1.ConfigMapInterface
	if rf, ok := ret.Get(0).(func(string) v1.ConfigMapInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.ConfigMapInterface)
		}
	}

	return r0
}

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

// ConfigMaps is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) ConfigMaps(namespace interface{}) *CoreV1Interface_ConfigMaps_Call {
	return &CoreV1Interface_ConfigMaps_Call{Call: _e.mock.On("ConfigMaps", namespace)}
}

func (_c *CoreV1Interface_ConfigMaps_Call) Run(run func(namespace string)) *CoreV1Interface_ConfigMaps_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_ConfigMaps_Call) Return(_a0 v1.ConfigMapInterface) *CoreV1Interface_ConfigMaps_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_ConfigMaps_Call) RunAndReturn(run func(string) v1.ConfigMapInterface) *CoreV1Interface_ConfigMaps_Call {
	_c.Call.Return(run)
	return _c
}

// Endpoints provides a mock function with given fields: namespace
func (_m *CoreV1Interface) Endpoints(namespace string) v1.EndpointsInterface {
	ret := _m.Called(namespace)

	var r0 v1.EndpointsInterface
	if rf, ok := ret.Get(0).(func(string) v1.EndpointsInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.EndpointsInterface)
		}
	}

	return r0
}

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

// Endpoints is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) Endpoints(namespace interface{}) *CoreV1Interface_Endpoints_Call {
	return &CoreV1Interface_Endpoints_Call{Call: _e.mock.On("Endpoints", namespace)}
}

func (_c *CoreV1Interface_Endpoints_Call) Run(run func(namespace string)) *CoreV1Interface_Endpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_Endpoints_Call) Return(_a0 v1.EndpointsInterface) *CoreV1Interface_Endpoints_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_Endpoints_Call) RunAndReturn(run func(string) v1.EndpointsInterface) *CoreV1Interface_Endpoints_Call {
	_c.Call.Return(run)
	return _c
}

// Events provides a mock function with given fields: namespace
func (_m *CoreV1Interface) Events(namespace string) v1.EventInterface {
	ret := _m.Called(namespace)

	var r0 v1.EventInterface
	if rf, ok := ret.Get(0).(func(string) v1.EventInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.EventInterface)
		}
	}

	return r0
}

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

// Events is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) Events(namespace interface{}) *CoreV1Interface_Events_Call {
	return &CoreV1Interface_Events_Call{Call: _e.mock.On("Events", namespace)}
}

func (_c *CoreV1Interface_Events_Call) Run(run func(namespace string)) *CoreV1Interface_Events_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_Events_Call) Return(_a0 v1.EventInterface) *CoreV1Interface_Events_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_Events_Call) RunAndReturn(run func(string) v1.EventInterface) *CoreV1Interface_Events_Call {
	_c.Call.Return(run)
	return _c
}

// LimitRanges provides a mock function with given fields: namespace
func (_m *CoreV1Interface) LimitRanges(namespace string) v1.LimitRangeInterface {
	ret := _m.Called(namespace)

	var r0 v1.LimitRangeInterface
	if rf, ok := ret.Get(0).(func(string) v1.LimitRangeInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.LimitRangeInterface)
		}
	}

	return r0
}

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

// LimitRanges is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) LimitRanges(namespace interface{}) *CoreV1Interface_LimitRanges_Call {
	return &CoreV1Interface_LimitRanges_Call{Call: _e.mock.On("LimitRanges", namespace)}
}

func (_c *CoreV1Interface_LimitRanges_Call) Run(run func(namespace string)) *CoreV1Interface_LimitRanges_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_LimitRanges_Call) Return(_a0 v1.LimitRangeInterface) *CoreV1Interface_LimitRanges_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_LimitRanges_Call) RunAndReturn(run func(string) v1.LimitRangeInterface) *CoreV1Interface_LimitRanges_Call {
	_c.Call.Return(run)
	return _c
}

// Namespaces provides a mock function with given fields:
func (_m *CoreV1Interface) Namespaces() v1.NamespaceInterface {
	ret := _m.Called()

	var r0 v1.NamespaceInterface
	if rf, ok := ret.Get(0).(func() v1.NamespaceInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.NamespaceInterface)
		}
	}

	return r0
}

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

// Namespaces is a helper method to define mock.On call
func (_e *CoreV1Interface_Expecter) Namespaces() *CoreV1Interface_Namespaces_Call {
	return &CoreV1Interface_Namespaces_Call{Call: _e.mock.On("Namespaces")}
}

func (_c *CoreV1Interface_Namespaces_Call) Run(run func()) *CoreV1Interface_Namespaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *CoreV1Interface_Namespaces_Call) Return(_a0 v1.NamespaceInterface) *CoreV1Interface_Namespaces_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_Namespaces_Call) RunAndReturn(run func() v1.NamespaceInterface) *CoreV1Interface_Namespaces_Call {
	_c.Call.Return(run)
	return _c
}

// Nodes provides a mock function with given fields:
func (_m *CoreV1Interface) Nodes() v1.NodeInterface {
	ret := _m.Called()

	var r0 v1.NodeInterface
	if rf, ok := ret.Get(0).(func() v1.NodeInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.NodeInterface)
		}
	}

	return r0
}

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

// Nodes is a helper method to define mock.On call
func (_e *CoreV1Interface_Expecter) Nodes() *CoreV1Interface_Nodes_Call {
	return &CoreV1Interface_Nodes_Call{Call: _e.mock.On("Nodes")}
}

func (_c *CoreV1Interface_Nodes_Call) Run(run func()) *CoreV1Interface_Nodes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *CoreV1Interface_Nodes_Call) Return(_a0 v1.NodeInterface) *CoreV1Interface_Nodes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_Nodes_Call) RunAndReturn(run func() v1.NodeInterface) *CoreV1Interface_Nodes_Call {
	_c.Call.Return(run)
	return _c
}

// PersistentVolumeClaims provides a mock function with given fields: namespace
func (_m *CoreV1Interface) PersistentVolumeClaims(namespace string) v1.PersistentVolumeClaimInterface {
	ret := _m.Called(namespace)

	var r0 v1.PersistentVolumeClaimInterface
	if rf, ok := ret.Get(0).(func(string) v1.PersistentVolumeClaimInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.PersistentVolumeClaimInterface)
		}
	}

	return r0
}

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

// PersistentVolumeClaims is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) PersistentVolumeClaims(namespace interface{}) *CoreV1Interface_PersistentVolumeClaims_Call {
	return &CoreV1Interface_PersistentVolumeClaims_Call{Call: _e.mock.On("PersistentVolumeClaims", namespace)}
}

func (_c *CoreV1Interface_PersistentVolumeClaims_Call) Run(run func(namespace string)) *CoreV1Interface_PersistentVolumeClaims_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_PersistentVolumeClaims_Call) Return(_a0 v1.PersistentVolumeClaimInterface) *CoreV1Interface_PersistentVolumeClaims_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_PersistentVolumeClaims_Call) RunAndReturn(run func(string) v1.PersistentVolumeClaimInterface) *CoreV1Interface_PersistentVolumeClaims_Call {
	_c.Call.Return(run)
	return _c
}

// PersistentVolumes provides a mock function with given fields:
func (_m *CoreV1Interface) PersistentVolumes() v1.PersistentVolumeInterface {
	ret := _m.Called()

	var r0 v1.PersistentVolumeInterface
	if rf, ok := ret.Get(0).(func() v1.PersistentVolumeInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.PersistentVolumeInterface)
		}
	}

	return r0
}

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

// PersistentVolumes is a helper method to define mock.On call
func (_e *CoreV1Interface_Expecter) PersistentVolumes() *CoreV1Interface_PersistentVolumes_Call {
	return &CoreV1Interface_PersistentVolumes_Call{Call: _e.mock.On("PersistentVolumes")}
}

func (_c *CoreV1Interface_PersistentVolumes_Call) Run(run func()) *CoreV1Interface_PersistentVolumes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *CoreV1Interface_PersistentVolumes_Call) Return(_a0 v1.PersistentVolumeInterface) *CoreV1Interface_PersistentVolumes_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_PersistentVolumes_Call) RunAndReturn(run func() v1.PersistentVolumeInterface) *CoreV1Interface_PersistentVolumes_Call {
	_c.Call.Return(run)
	return _c
}

// PodTemplates provides a mock function with given fields: namespace
func (_m *CoreV1Interface) PodTemplates(namespace string) v1.PodTemplateInterface {
	ret := _m.Called(namespace)

	var r0 v1.PodTemplateInterface
	if rf, ok := ret.Get(0).(func(string) v1.PodTemplateInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.PodTemplateInterface)
		}
	}

	return r0
}

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

// PodTemplates is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) PodTemplates(namespace interface{}) *CoreV1Interface_PodTemplates_Call {
	return &CoreV1Interface_PodTemplates_Call{Call: _e.mock.On("PodTemplates", namespace)}
}

func (_c *CoreV1Interface_PodTemplates_Call) Run(run func(namespace string)) *CoreV1Interface_PodTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_PodTemplates_Call) Return(_a0 v1.PodTemplateInterface) *CoreV1Interface_PodTemplates_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_PodTemplates_Call) RunAndReturn(run func(string) v1.PodTemplateInterface) *CoreV1Interface_PodTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// Pods provides a mock function with given fields: namespace
func (_m *CoreV1Interface) Pods(namespace string) v1.PodInterface {
	ret := _m.Called(namespace)

	var r0 v1.PodInterface
	if rf, ok := ret.Get(0).(func(string) v1.PodInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.PodInterface)
		}
	}

	return r0
}

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

// Pods is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) Pods(namespace interface{}) *CoreV1Interface_Pods_Call {
	return &CoreV1Interface_Pods_Call{Call: _e.mock.On("Pods", namespace)}
}

func (_c *CoreV1Interface_Pods_Call) Run(run func(namespace string)) *CoreV1Interface_Pods_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_Pods_Call) Return(_a0 v1.PodInterface) *CoreV1Interface_Pods_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_Pods_Call) RunAndReturn(run func(string) v1.PodInterface) *CoreV1Interface_Pods_Call {
	_c.Call.Return(run)
	return _c
}

// RESTClient provides a mock function with given fields:
func (_m *CoreV1Interface) RESTClient() rest.Interface {
	ret := _m.Called()

	var r0 rest.Interface
	if rf, ok := ret.Get(0).(func() rest.Interface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(rest.Interface)
		}
	}

	return r0
}

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

// RESTClient is a helper method to define mock.On call
func (_e *CoreV1Interface_Expecter) RESTClient() *CoreV1Interface_RESTClient_Call {
	return &CoreV1Interface_RESTClient_Call{Call: _e.mock.On("RESTClient")}
}

func (_c *CoreV1Interface_RESTClient_Call) Run(run func()) *CoreV1Interface_RESTClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *CoreV1Interface_RESTClient_Call) Return(_a0 rest.Interface) *CoreV1Interface_RESTClient_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_RESTClient_Call) RunAndReturn(run func() rest.Interface) *CoreV1Interface_RESTClient_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicationControllers provides a mock function with given fields: namespace
func (_m *CoreV1Interface) ReplicationControllers(namespace string) v1.ReplicationControllerInterface {
	ret := _m.Called(namespace)

	var r0 v1.ReplicationControllerInterface
	if rf, ok := ret.Get(0).(func(string) v1.ReplicationControllerInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.ReplicationControllerInterface)
		}
	}

	return r0
}

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

// ReplicationControllers is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) ReplicationControllers(namespace interface{}) *CoreV1Interface_ReplicationControllers_Call {
	return &CoreV1Interface_ReplicationControllers_Call{Call: _e.mock.On("ReplicationControllers", namespace)}
}

func (_c *CoreV1Interface_ReplicationControllers_Call) Run(run func(namespace string)) *CoreV1Interface_ReplicationControllers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_ReplicationControllers_Call) Return(_a0 v1.ReplicationControllerInterface) *CoreV1Interface_ReplicationControllers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_ReplicationControllers_Call) RunAndReturn(run func(string) v1.ReplicationControllerInterface) *CoreV1Interface_ReplicationControllers_Call {
	_c.Call.Return(run)
	return _c
}

// ResourceQuotas provides a mock function with given fields: namespace
func (_m *CoreV1Interface) ResourceQuotas(namespace string) v1.ResourceQuotaInterface {
	ret := _m.Called(namespace)

	var r0 v1.ResourceQuotaInterface
	if rf, ok := ret.Get(0).(func(string) v1.ResourceQuotaInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.ResourceQuotaInterface)
		}
	}

	return r0
}

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

// ResourceQuotas is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) ResourceQuotas(namespace interface{}) *CoreV1Interface_ResourceQuotas_Call {
	return &CoreV1Interface_ResourceQuotas_Call{Call: _e.mock.On("ResourceQuotas", namespace)}
}

func (_c *CoreV1Interface_ResourceQuotas_Call) Run(run func(namespace string)) *CoreV1Interface_ResourceQuotas_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_ResourceQuotas_Call) Return(_a0 v1.ResourceQuotaInterface) *CoreV1Interface_ResourceQuotas_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_ResourceQuotas_Call) RunAndReturn(run func(string) v1.ResourceQuotaInterface) *CoreV1Interface_ResourceQuotas_Call {
	_c.Call.Return(run)
	return _c
}

// Secrets provides a mock function with given fields: namespace
func (_m *CoreV1Interface) Secrets(namespace string) v1.SecretInterface {
	ret := _m.Called(namespace)

	var r0 v1.SecretInterface
	if rf, ok := ret.Get(0).(func(string) v1.SecretInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.SecretInterface)
		}
	}

	return r0
}

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

// Secrets is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) Secrets(namespace interface{}) *CoreV1Interface_Secrets_Call {
	return &CoreV1Interface_Secrets_Call{Call: _e.mock.On("Secrets", namespace)}
}

func (_c *CoreV1Interface_Secrets_Call) Run(run func(namespace string)) *CoreV1Interface_Secrets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_Secrets_Call) Return(_a0 v1.SecretInterface) *CoreV1Interface_Secrets_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_Secrets_Call) RunAndReturn(run func(string) v1.SecretInterface) *CoreV1Interface_Secrets_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceAccounts provides a mock function with given fields: namespace
func (_m *CoreV1Interface) ServiceAccounts(namespace string) v1.ServiceAccountInterface {
	ret := _m.Called(namespace)

	var r0 v1.ServiceAccountInterface
	if rf, ok := ret.Get(0).(func(string) v1.ServiceAccountInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.ServiceAccountInterface)
		}
	}

	return r0
}

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

// ServiceAccounts is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) ServiceAccounts(namespace interface{}) *CoreV1Interface_ServiceAccounts_Call {
	return &CoreV1Interface_ServiceAccounts_Call{Call: _e.mock.On("ServiceAccounts", namespace)}
}

func (_c *CoreV1Interface_ServiceAccounts_Call) Run(run func(namespace string)) *CoreV1Interface_ServiceAccounts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_ServiceAccounts_Call) Return(_a0 v1.ServiceAccountInterface) *CoreV1Interface_ServiceAccounts_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_ServiceAccounts_Call) RunAndReturn(run func(string) v1.ServiceAccountInterface) *CoreV1Interface_ServiceAccounts_Call {
	_c.Call.Return(run)
	return _c
}

// Services provides a mock function with given fields: namespace
func (_m *CoreV1Interface) Services(namespace string) v1.ServiceInterface {
	ret := _m.Called(namespace)

	var r0 v1.ServiceInterface
	if rf, ok := ret.Get(0).(func(string) v1.ServiceInterface); ok {
		r0 = rf(namespace)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1.ServiceInterface)
		}
	}

	return r0
}

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

// Services is a helper method to define mock.On call
//   - namespace string
func (_e *CoreV1Interface_Expecter) Services(namespace interface{}) *CoreV1Interface_Services_Call {
	return &CoreV1Interface_Services_Call{Call: _e.mock.On("Services", namespace)}
}

func (_c *CoreV1Interface_Services_Call) Run(run func(namespace string)) *CoreV1Interface_Services_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *CoreV1Interface_Services_Call) Return(_a0 v1.ServiceInterface) *CoreV1Interface_Services_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CoreV1Interface_Services_Call) RunAndReturn(run func(string) v1.ServiceInterface) *CoreV1Interface_Services_Call {
	_c.Call.Return(run)
	return _c
}

type mockConstructorTestingTNewCoreV1Interface interface {
	mock.TestingT
	Cleanup(func())
}

// NewCoreV1Interface creates a new instance of CoreV1Interface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewCoreV1Interface(t mockConstructorTestingTNewCoreV1Interface) *CoreV1Interface {
	mock := &CoreV1Interface{}
	mock.Mock.Test(t)

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

	return mock
}