fakes

package
Version: v0.0.0-...-aea36de Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 8, 2019 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DaemonSetControllerMock

type DaemonSetControllerMock struct {
	// AddClusterScopedHandlerFunc mocks the AddClusterScopedHandler method.
	AddClusterScopedHandlerFunc func(ctx context.Context, name string, clusterName string, handler v1beta2a.DaemonSetHandlerFunc)

	// AddHandlerFunc mocks the AddHandler method.
	AddHandlerFunc func(ctx context.Context, name string, handler v1beta2a.DaemonSetHandlerFunc)

	// EnqueueFunc mocks the Enqueue method.
	EnqueueFunc func(namespace string, name string)

	// GenericFunc mocks the Generic method.
	GenericFunc func() controller.GenericController

	// InformerFunc mocks the Informer method.
	InformerFunc func() cache.SharedIndexInformer

	// ListerFunc mocks the Lister method.
	ListerFunc func() v1beta2a.DaemonSetLister

	// StartFunc mocks the Start method.
	StartFunc func(ctx context.Context, threadiness int) error

	// SyncFunc mocks the Sync method.
	SyncFunc func(ctx context.Context) error
	// contains filtered or unexported fields
}

DaemonSetControllerMock is a mock implementation of DaemonSetController.

    func TestSomethingThatUsesDaemonSetController(t *testing.T) {

        // make and configure a mocked DaemonSetController
        mockedDaemonSetController := &DaemonSetControllerMock{
            AddClusterScopedHandlerFunc: func(ctx context.Context, name string, clusterName string, handler v1beta2a.DaemonSetHandlerFunc)  {
	               panic("mock out the AddClusterScopedHandler method")
            },
            AddHandlerFunc: func(ctx context.Context, name string, handler v1beta2a.DaemonSetHandlerFunc)  {
	               panic("mock out the AddHandler method")
            },
            EnqueueFunc: func(namespace string, name string)  {
	               panic("mock out the Enqueue method")
            },
            GenericFunc: func() controller.GenericController {
	               panic("mock out the Generic method")
            },
            InformerFunc: func() cache.SharedIndexInformer {
	               panic("mock out the Informer method")
            },
            ListerFunc: func() v1beta2a.DaemonSetLister {
	               panic("mock out the Lister method")
            },
            StartFunc: func(ctx context.Context, threadiness int) error {
	               panic("mock out the Start method")
            },
            SyncFunc: func(ctx context.Context) error {
	               panic("mock out the Sync method")
            },
        }

        // use mockedDaemonSetController in code that requires DaemonSetController
        // and then make assertions.

    }

func (*DaemonSetControllerMock) AddClusterScopedHandler

func (mock *DaemonSetControllerMock) AddClusterScopedHandler(ctx context.Context, name string, clusterName string, handler v1beta2a.DaemonSetHandlerFunc)

AddClusterScopedHandler calls AddClusterScopedHandlerFunc.

func (*DaemonSetControllerMock) AddClusterScopedHandlerCalls

func (mock *DaemonSetControllerMock) AddClusterScopedHandlerCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Handler     v1beta2a.DaemonSetHandlerFunc
}

AddClusterScopedHandlerCalls gets all the calls that were made to AddClusterScopedHandler. Check the length with:

len(mockedDaemonSetController.AddClusterScopedHandlerCalls())

func (*DaemonSetControllerMock) AddHandler

func (mock *DaemonSetControllerMock) AddHandler(ctx context.Context, name string, handler v1beta2a.DaemonSetHandlerFunc)

AddHandler calls AddHandlerFunc.

func (*DaemonSetControllerMock) AddHandlerCalls

func (mock *DaemonSetControllerMock) AddHandlerCalls() []struct {
	Ctx     context.Context
	Name    string
	Handler v1beta2a.DaemonSetHandlerFunc
}

AddHandlerCalls gets all the calls that were made to AddHandler. Check the length with:

len(mockedDaemonSetController.AddHandlerCalls())

func (*DaemonSetControllerMock) Enqueue

func (mock *DaemonSetControllerMock) Enqueue(namespace string, name string)

Enqueue calls EnqueueFunc.

func (*DaemonSetControllerMock) EnqueueCalls

func (mock *DaemonSetControllerMock) EnqueueCalls() []struct {
	Namespace string
	Name      string
}

EnqueueCalls gets all the calls that were made to Enqueue. Check the length with:

len(mockedDaemonSetController.EnqueueCalls())

func (*DaemonSetControllerMock) Generic

Generic calls GenericFunc.

func (*DaemonSetControllerMock) GenericCalls

func (mock *DaemonSetControllerMock) GenericCalls() []struct {
}

GenericCalls gets all the calls that were made to Generic. Check the length with:

len(mockedDaemonSetController.GenericCalls())

func (*DaemonSetControllerMock) Informer

Informer calls InformerFunc.

func (*DaemonSetControllerMock) InformerCalls

func (mock *DaemonSetControllerMock) InformerCalls() []struct {
}

InformerCalls gets all the calls that were made to Informer. Check the length with:

len(mockedDaemonSetController.InformerCalls())

func (*DaemonSetControllerMock) Lister

Lister calls ListerFunc.

func (*DaemonSetControllerMock) ListerCalls

func (mock *DaemonSetControllerMock) ListerCalls() []struct {
}

ListerCalls gets all the calls that were made to Lister. Check the length with:

len(mockedDaemonSetController.ListerCalls())

func (*DaemonSetControllerMock) Start

func (mock *DaemonSetControllerMock) Start(ctx context.Context, threadiness int) error

Start calls StartFunc.

func (*DaemonSetControllerMock) StartCalls

func (mock *DaemonSetControllerMock) StartCalls() []struct {
	Ctx         context.Context
	Threadiness int
}

StartCalls gets all the calls that were made to Start. Check the length with:

len(mockedDaemonSetController.StartCalls())

func (*DaemonSetControllerMock) Sync

func (mock *DaemonSetControllerMock) Sync(ctx context.Context) error

Sync calls SyncFunc.

func (*DaemonSetControllerMock) SyncCalls

func (mock *DaemonSetControllerMock) SyncCalls() []struct {
	Ctx context.Context
}

SyncCalls gets all the calls that were made to Sync. Check the length with:

len(mockedDaemonSetController.SyncCalls())

type DaemonSetInterfaceMock

type DaemonSetInterfaceMock struct {
	// AddClusterScopedHandlerFunc mocks the AddClusterScopedHandler method.
	AddClusterScopedHandlerFunc func(ctx context.Context, name string, clusterName string, sync v1beta2a.DaemonSetHandlerFunc)

	// AddClusterScopedLifecycleFunc mocks the AddClusterScopedLifecycle method.
	AddClusterScopedLifecycleFunc func(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.DaemonSetLifecycle)

	// AddHandlerFunc mocks the AddHandler method.
	AddHandlerFunc func(ctx context.Context, name string, sync v1beta2a.DaemonSetHandlerFunc)

	// AddLifecycleFunc mocks the AddLifecycle method.
	AddLifecycleFunc func(ctx context.Context, name string, lifecycle v1beta2a.DaemonSetLifecycle)

	// ControllerFunc mocks the Controller method.
	ControllerFunc func() v1beta2a.DaemonSetController

	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1beta2.DaemonSet) (*v1beta2.DaemonSet, error)

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(name string, options *v1.DeleteOptions) error

	// DeleteCollectionFunc mocks the DeleteCollection method.
	DeleteCollectionFunc func(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error

	// DeleteNamespacedFunc mocks the DeleteNamespaced method.
	DeleteNamespacedFunc func(namespace string, name string, options *v1.DeleteOptions) error

	// GetFunc mocks the Get method.
	GetFunc func(name string, opts v1.GetOptions) (*v1beta2.DaemonSet, error)

	// GetNamespacedFunc mocks the GetNamespaced method.
	GetNamespacedFunc func(namespace string, name string, opts v1.GetOptions) (*v1beta2.DaemonSet, error)

	// ListFunc mocks the List method.
	ListFunc func(opts v1.ListOptions) (*v1beta2a.DaemonSetList, error)

	// ObjectClientFunc mocks the ObjectClient method.
	ObjectClientFunc func() *objectclient.ObjectClient

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 *v1beta2.DaemonSet) (*v1beta2.DaemonSet, error)

	// WatchFunc mocks the Watch method.
	WatchFunc func(opts v1.ListOptions) (watch.Interface, error)
	// contains filtered or unexported fields
}

DaemonSetInterfaceMock is a mock implementation of DaemonSetInterface.

    func TestSomethingThatUsesDaemonSetInterface(t *testing.T) {

        // make and configure a mocked DaemonSetInterface
        mockedDaemonSetInterface := &DaemonSetInterfaceMock{
            AddClusterScopedHandlerFunc: func(ctx context.Context, name string, clusterName string, sync v1beta2a.DaemonSetHandlerFunc)  {
	               panic("mock out the AddClusterScopedHandler method")
            },
            AddClusterScopedLifecycleFunc: func(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.DaemonSetLifecycle)  {
	               panic("mock out the AddClusterScopedLifecycle method")
            },
            AddHandlerFunc: func(ctx context.Context, name string, sync v1beta2a.DaemonSetHandlerFunc)  {
	               panic("mock out the AddHandler method")
            },
            AddLifecycleFunc: func(ctx context.Context, name string, lifecycle v1beta2a.DaemonSetLifecycle)  {
	               panic("mock out the AddLifecycle method")
            },
            ControllerFunc: func() v1beta2a.DaemonSetController {
	               panic("mock out the Controller method")
            },
            CreateFunc: func(in1 *v1beta2.DaemonSet) (*v1beta2.DaemonSet, error) {
	               panic("mock out the Create method")
            },
            DeleteFunc: func(name string, options *v1.DeleteOptions) error {
	               panic("mock out the Delete method")
            },
            DeleteCollectionFunc: func(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error {
	               panic("mock out the DeleteCollection method")
            },
            DeleteNamespacedFunc: func(namespace string, name string, options *v1.DeleteOptions) error {
	               panic("mock out the DeleteNamespaced method")
            },
            GetFunc: func(name string, opts v1.GetOptions) (*v1beta2.DaemonSet, error) {
	               panic("mock out the Get method")
            },
            GetNamespacedFunc: func(namespace string, name string, opts v1.GetOptions) (*v1beta2.DaemonSet, error) {
	               panic("mock out the GetNamespaced method")
            },
            ListFunc: func(opts v1.ListOptions) (*v1beta2a.DaemonSetList, error) {
	               panic("mock out the List method")
            },
            ObjectClientFunc: func() *objectclient.ObjectClient {
	               panic("mock out the ObjectClient method")
            },
            UpdateFunc: func(in1 *v1beta2.DaemonSet) (*v1beta2.DaemonSet, error) {
	               panic("mock out the Update method")
            },
            WatchFunc: func(opts v1.ListOptions) (watch.Interface, error) {
	               panic("mock out the Watch method")
            },
        }

        // use mockedDaemonSetInterface in code that requires DaemonSetInterface
        // and then make assertions.

    }

func (*DaemonSetInterfaceMock) AddClusterScopedHandler

func (mock *DaemonSetInterfaceMock) AddClusterScopedHandler(ctx context.Context, name string, clusterName string, sync v1beta2a.DaemonSetHandlerFunc)

AddClusterScopedHandler calls AddClusterScopedHandlerFunc.

func (*DaemonSetInterfaceMock) AddClusterScopedHandlerCalls

func (mock *DaemonSetInterfaceMock) AddClusterScopedHandlerCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Sync        v1beta2a.DaemonSetHandlerFunc
}

AddClusterScopedHandlerCalls gets all the calls that were made to AddClusterScopedHandler. Check the length with:

len(mockedDaemonSetInterface.AddClusterScopedHandlerCalls())

func (*DaemonSetInterfaceMock) AddClusterScopedLifecycle

func (mock *DaemonSetInterfaceMock) AddClusterScopedLifecycle(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.DaemonSetLifecycle)

AddClusterScopedLifecycle calls AddClusterScopedLifecycleFunc.

func (*DaemonSetInterfaceMock) AddClusterScopedLifecycleCalls

func (mock *DaemonSetInterfaceMock) AddClusterScopedLifecycleCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Lifecycle   v1beta2a.DaemonSetLifecycle
}

AddClusterScopedLifecycleCalls gets all the calls that were made to AddClusterScopedLifecycle. Check the length with:

len(mockedDaemonSetInterface.AddClusterScopedLifecycleCalls())

func (*DaemonSetInterfaceMock) AddHandler

func (mock *DaemonSetInterfaceMock) AddHandler(ctx context.Context, name string, sync v1beta2a.DaemonSetHandlerFunc)

AddHandler calls AddHandlerFunc.

func (*DaemonSetInterfaceMock) AddHandlerCalls

func (mock *DaemonSetInterfaceMock) AddHandlerCalls() []struct {
	Ctx  context.Context
	Name string
	Sync v1beta2a.DaemonSetHandlerFunc
}

AddHandlerCalls gets all the calls that were made to AddHandler. Check the length with:

len(mockedDaemonSetInterface.AddHandlerCalls())

func (*DaemonSetInterfaceMock) AddLifecycle

func (mock *DaemonSetInterfaceMock) AddLifecycle(ctx context.Context, name string, lifecycle v1beta2a.DaemonSetLifecycle)

AddLifecycle calls AddLifecycleFunc.

func (*DaemonSetInterfaceMock) AddLifecycleCalls

func (mock *DaemonSetInterfaceMock) AddLifecycleCalls() []struct {
	Ctx       context.Context
	Name      string
	Lifecycle v1beta2a.DaemonSetLifecycle
}

AddLifecycleCalls gets all the calls that were made to AddLifecycle. Check the length with:

len(mockedDaemonSetInterface.AddLifecycleCalls())

func (*DaemonSetInterfaceMock) Controller

Controller calls ControllerFunc.

func (*DaemonSetInterfaceMock) ControllerCalls

func (mock *DaemonSetInterfaceMock) ControllerCalls() []struct {
}

ControllerCalls gets all the calls that were made to Controller. Check the length with:

len(mockedDaemonSetInterface.ControllerCalls())

func (*DaemonSetInterfaceMock) Create

Create calls CreateFunc.

func (*DaemonSetInterfaceMock) CreateCalls

func (mock *DaemonSetInterfaceMock) CreateCalls() []struct {
	In1 *v1beta2.DaemonSet
}

CreateCalls gets all the calls that were made to Create. Check the length with:

len(mockedDaemonSetInterface.CreateCalls())

func (*DaemonSetInterfaceMock) Delete

func (mock *DaemonSetInterfaceMock) Delete(name string, options *v1.DeleteOptions) error

Delete calls DeleteFunc.

func (*DaemonSetInterfaceMock) DeleteCalls

func (mock *DaemonSetInterfaceMock) DeleteCalls() []struct {
	Name    string
	Options *v1.DeleteOptions
}

DeleteCalls gets all the calls that were made to Delete. Check the length with:

len(mockedDaemonSetInterface.DeleteCalls())

func (*DaemonSetInterfaceMock) DeleteCollection

func (mock *DaemonSetInterfaceMock) DeleteCollection(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error

DeleteCollection calls DeleteCollectionFunc.

func (*DaemonSetInterfaceMock) DeleteCollectionCalls

func (mock *DaemonSetInterfaceMock) DeleteCollectionCalls() []struct {
	DeleteOpts *v1.DeleteOptions
	ListOpts   v1.ListOptions
}

DeleteCollectionCalls gets all the calls that were made to DeleteCollection. Check the length with:

len(mockedDaemonSetInterface.DeleteCollectionCalls())

func (*DaemonSetInterfaceMock) DeleteNamespaced

func (mock *DaemonSetInterfaceMock) DeleteNamespaced(namespace string, name string, options *v1.DeleteOptions) error

DeleteNamespaced calls DeleteNamespacedFunc.

func (*DaemonSetInterfaceMock) DeleteNamespacedCalls

func (mock *DaemonSetInterfaceMock) DeleteNamespacedCalls() []struct {
	Namespace string
	Name      string
	Options   *v1.DeleteOptions
}

DeleteNamespacedCalls gets all the calls that were made to DeleteNamespaced. Check the length with:

len(mockedDaemonSetInterface.DeleteNamespacedCalls())

func (*DaemonSetInterfaceMock) Get

func (mock *DaemonSetInterfaceMock) Get(name string, opts v1.GetOptions) (*v1beta2.DaemonSet, error)

Get calls GetFunc.

func (*DaemonSetInterfaceMock) GetCalls

func (mock *DaemonSetInterfaceMock) GetCalls() []struct {
	Name string
	Opts v1.GetOptions
}

GetCalls gets all the calls that were made to Get. Check the length with:

len(mockedDaemonSetInterface.GetCalls())

func (*DaemonSetInterfaceMock) GetNamespaced

func (mock *DaemonSetInterfaceMock) GetNamespaced(namespace string, name string, opts v1.GetOptions) (*v1beta2.DaemonSet, error)

GetNamespaced calls GetNamespacedFunc.

func (*DaemonSetInterfaceMock) GetNamespacedCalls

func (mock *DaemonSetInterfaceMock) GetNamespacedCalls() []struct {
	Namespace string
	Name      string
	Opts      v1.GetOptions
}

GetNamespacedCalls gets all the calls that were made to GetNamespaced. Check the length with:

len(mockedDaemonSetInterface.GetNamespacedCalls())

func (*DaemonSetInterfaceMock) List

List calls ListFunc.

func (*DaemonSetInterfaceMock) ListCalls

func (mock *DaemonSetInterfaceMock) ListCalls() []struct {
	Opts v1.ListOptions
}

ListCalls gets all the calls that were made to List. Check the length with:

len(mockedDaemonSetInterface.ListCalls())

func (*DaemonSetInterfaceMock) ObjectClient

func (mock *DaemonSetInterfaceMock) ObjectClient() *objectclient.ObjectClient

ObjectClient calls ObjectClientFunc.

func (*DaemonSetInterfaceMock) ObjectClientCalls

func (mock *DaemonSetInterfaceMock) ObjectClientCalls() []struct {
}

ObjectClientCalls gets all the calls that were made to ObjectClient. Check the length with:

len(mockedDaemonSetInterface.ObjectClientCalls())

func (*DaemonSetInterfaceMock) Update

Update calls UpdateFunc.

func (*DaemonSetInterfaceMock) UpdateCalls

func (mock *DaemonSetInterfaceMock) UpdateCalls() []struct {
	In1 *v1beta2.DaemonSet
}

UpdateCalls gets all the calls that were made to Update. Check the length with:

len(mockedDaemonSetInterface.UpdateCalls())

func (*DaemonSetInterfaceMock) Watch

Watch calls WatchFunc.

func (*DaemonSetInterfaceMock) WatchCalls

func (mock *DaemonSetInterfaceMock) WatchCalls() []struct {
	Opts v1.ListOptions
}

WatchCalls gets all the calls that were made to Watch. Check the length with:

len(mockedDaemonSetInterface.WatchCalls())

type DaemonSetListerMock

type DaemonSetListerMock struct {
	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string) (*v1beta2.DaemonSet, error)

	// ListFunc mocks the List method.
	ListFunc func(namespace string, selector labels.Selector) ([]*v1beta2.DaemonSet, error)
	// contains filtered or unexported fields
}

DaemonSetListerMock is a mock implementation of DaemonSetLister.

    func TestSomethingThatUsesDaemonSetLister(t *testing.T) {

        // make and configure a mocked DaemonSetLister
        mockedDaemonSetLister := &DaemonSetListerMock{
            GetFunc: func(namespace string, name string) (*v1beta2.DaemonSet, error) {
	               panic("mock out the Get method")
            },
            ListFunc: func(namespace string, selector labels.Selector) ([]*v1beta2.DaemonSet, error) {
	               panic("mock out the List method")
            },
        }

        // use mockedDaemonSetLister in code that requires DaemonSetLister
        // and then make assertions.

    }

func (*DaemonSetListerMock) Get

func (mock *DaemonSetListerMock) Get(namespace string, name string) (*v1beta2.DaemonSet, error)

Get calls GetFunc.

func (*DaemonSetListerMock) GetCalls

func (mock *DaemonSetListerMock) GetCalls() []struct {
	Namespace string
	Name      string
}

GetCalls gets all the calls that were made to Get. Check the length with:

len(mockedDaemonSetLister.GetCalls())

func (*DaemonSetListerMock) List

func (mock *DaemonSetListerMock) List(namespace string, selector labels.Selector) ([]*v1beta2.DaemonSet, error)

List calls ListFunc.

func (*DaemonSetListerMock) ListCalls

func (mock *DaemonSetListerMock) ListCalls() []struct {
	Namespace string
	Selector  labels.Selector
}

ListCalls gets all the calls that were made to List. Check the length with:

len(mockedDaemonSetLister.ListCalls())

type DaemonSetsGetterMock

type DaemonSetsGetterMock struct {
	// DaemonSetsFunc mocks the DaemonSets method.
	DaemonSetsFunc func(namespace string) v1beta2a.DaemonSetInterface
	// contains filtered or unexported fields
}

DaemonSetsGetterMock is a mock implementation of DaemonSetsGetter.

    func TestSomethingThatUsesDaemonSetsGetter(t *testing.T) {

        // make and configure a mocked DaemonSetsGetter
        mockedDaemonSetsGetter := &DaemonSetsGetterMock{
            DaemonSetsFunc: func(namespace string) v1beta2a.DaemonSetInterface {
	               panic("mock out the DaemonSets method")
            },
        }

        // use mockedDaemonSetsGetter in code that requires DaemonSetsGetter
        // and then make assertions.

    }

func (*DaemonSetsGetterMock) DaemonSets

func (mock *DaemonSetsGetterMock) DaemonSets(namespace string) v1beta2a.DaemonSetInterface

DaemonSets calls DaemonSetsFunc.

func (*DaemonSetsGetterMock) DaemonSetsCalls

func (mock *DaemonSetsGetterMock) DaemonSetsCalls() []struct {
	Namespace string
}

DaemonSetsCalls gets all the calls that were made to DaemonSets. Check the length with:

len(mockedDaemonSetsGetter.DaemonSetsCalls())

type DeploymentControllerMock

type DeploymentControllerMock struct {
	// AddClusterScopedHandlerFunc mocks the AddClusterScopedHandler method.
	AddClusterScopedHandlerFunc func(ctx context.Context, name string, clusterName string, handler v1beta2a.DeploymentHandlerFunc)

	// AddHandlerFunc mocks the AddHandler method.
	AddHandlerFunc func(ctx context.Context, name string, handler v1beta2a.DeploymentHandlerFunc)

	// EnqueueFunc mocks the Enqueue method.
	EnqueueFunc func(namespace string, name string)

	// GenericFunc mocks the Generic method.
	GenericFunc func() controller.GenericController

	// InformerFunc mocks the Informer method.
	InformerFunc func() cache.SharedIndexInformer

	// ListerFunc mocks the Lister method.
	ListerFunc func() v1beta2a.DeploymentLister

	// StartFunc mocks the Start method.
	StartFunc func(ctx context.Context, threadiness int) error

	// SyncFunc mocks the Sync method.
	SyncFunc func(ctx context.Context) error
	// contains filtered or unexported fields
}

DeploymentControllerMock is a mock implementation of DeploymentController.

    func TestSomethingThatUsesDeploymentController(t *testing.T) {

        // make and configure a mocked DeploymentController
        mockedDeploymentController := &DeploymentControllerMock{
            AddClusterScopedHandlerFunc: func(ctx context.Context, name string, clusterName string, handler v1beta2a.DeploymentHandlerFunc)  {
	               panic("mock out the AddClusterScopedHandler method")
            },
            AddHandlerFunc: func(ctx context.Context, name string, handler v1beta2a.DeploymentHandlerFunc)  {
	               panic("mock out the AddHandler method")
            },
            EnqueueFunc: func(namespace string, name string)  {
	               panic("mock out the Enqueue method")
            },
            GenericFunc: func() controller.GenericController {
	               panic("mock out the Generic method")
            },
            InformerFunc: func() cache.SharedIndexInformer {
	               panic("mock out the Informer method")
            },
            ListerFunc: func() v1beta2a.DeploymentLister {
	               panic("mock out the Lister method")
            },
            StartFunc: func(ctx context.Context, threadiness int) error {
	               panic("mock out the Start method")
            },
            SyncFunc: func(ctx context.Context) error {
	               panic("mock out the Sync method")
            },
        }

        // use mockedDeploymentController in code that requires DeploymentController
        // and then make assertions.

    }

func (*DeploymentControllerMock) AddClusterScopedHandler

func (mock *DeploymentControllerMock) AddClusterScopedHandler(ctx context.Context, name string, clusterName string, handler v1beta2a.DeploymentHandlerFunc)

AddClusterScopedHandler calls AddClusterScopedHandlerFunc.

func (*DeploymentControllerMock) AddClusterScopedHandlerCalls

func (mock *DeploymentControllerMock) AddClusterScopedHandlerCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Handler     v1beta2a.DeploymentHandlerFunc
}

AddClusterScopedHandlerCalls gets all the calls that were made to AddClusterScopedHandler. Check the length with:

len(mockedDeploymentController.AddClusterScopedHandlerCalls())

func (*DeploymentControllerMock) AddHandler

func (mock *DeploymentControllerMock) AddHandler(ctx context.Context, name string, handler v1beta2a.DeploymentHandlerFunc)

AddHandler calls AddHandlerFunc.

func (*DeploymentControllerMock) AddHandlerCalls

func (mock *DeploymentControllerMock) AddHandlerCalls() []struct {
	Ctx     context.Context
	Name    string
	Handler v1beta2a.DeploymentHandlerFunc
}

AddHandlerCalls gets all the calls that were made to AddHandler. Check the length with:

len(mockedDeploymentController.AddHandlerCalls())

func (*DeploymentControllerMock) Enqueue

func (mock *DeploymentControllerMock) Enqueue(namespace string, name string)

Enqueue calls EnqueueFunc.

func (*DeploymentControllerMock) EnqueueCalls

func (mock *DeploymentControllerMock) EnqueueCalls() []struct {
	Namespace string
	Name      string
}

EnqueueCalls gets all the calls that were made to Enqueue. Check the length with:

len(mockedDeploymentController.EnqueueCalls())

func (*DeploymentControllerMock) Generic

Generic calls GenericFunc.

func (*DeploymentControllerMock) GenericCalls

func (mock *DeploymentControllerMock) GenericCalls() []struct {
}

GenericCalls gets all the calls that were made to Generic. Check the length with:

len(mockedDeploymentController.GenericCalls())

func (*DeploymentControllerMock) Informer

Informer calls InformerFunc.

func (*DeploymentControllerMock) InformerCalls

func (mock *DeploymentControllerMock) InformerCalls() []struct {
}

InformerCalls gets all the calls that were made to Informer. Check the length with:

len(mockedDeploymentController.InformerCalls())

func (*DeploymentControllerMock) Lister

Lister calls ListerFunc.

func (*DeploymentControllerMock) ListerCalls

func (mock *DeploymentControllerMock) ListerCalls() []struct {
}

ListerCalls gets all the calls that were made to Lister. Check the length with:

len(mockedDeploymentController.ListerCalls())

func (*DeploymentControllerMock) Start

func (mock *DeploymentControllerMock) Start(ctx context.Context, threadiness int) error

Start calls StartFunc.

func (*DeploymentControllerMock) StartCalls

func (mock *DeploymentControllerMock) StartCalls() []struct {
	Ctx         context.Context
	Threadiness int
}

StartCalls gets all the calls that were made to Start. Check the length with:

len(mockedDeploymentController.StartCalls())

func (*DeploymentControllerMock) Sync

Sync calls SyncFunc.

func (*DeploymentControllerMock) SyncCalls

func (mock *DeploymentControllerMock) SyncCalls() []struct {
	Ctx context.Context
}

SyncCalls gets all the calls that were made to Sync. Check the length with:

len(mockedDeploymentController.SyncCalls())

type DeploymentInterfaceMock

type DeploymentInterfaceMock struct {
	// AddClusterScopedHandlerFunc mocks the AddClusterScopedHandler method.
	AddClusterScopedHandlerFunc func(ctx context.Context, name string, clusterName string, sync v1beta2a.DeploymentHandlerFunc)

	// AddClusterScopedLifecycleFunc mocks the AddClusterScopedLifecycle method.
	AddClusterScopedLifecycleFunc func(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.DeploymentLifecycle)

	// AddHandlerFunc mocks the AddHandler method.
	AddHandlerFunc func(ctx context.Context, name string, sync v1beta2a.DeploymentHandlerFunc)

	// AddLifecycleFunc mocks the AddLifecycle method.
	AddLifecycleFunc func(ctx context.Context, name string, lifecycle v1beta2a.DeploymentLifecycle)

	// ControllerFunc mocks the Controller method.
	ControllerFunc func() v1beta2a.DeploymentController

	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1beta2.Deployment) (*v1beta2.Deployment, error)

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(name string, options *v1.DeleteOptions) error

	// DeleteCollectionFunc mocks the DeleteCollection method.
	DeleteCollectionFunc func(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error

	// DeleteNamespacedFunc mocks the DeleteNamespaced method.
	DeleteNamespacedFunc func(namespace string, name string, options *v1.DeleteOptions) error

	// GetFunc mocks the Get method.
	GetFunc func(name string, opts v1.GetOptions) (*v1beta2.Deployment, error)

	// GetNamespacedFunc mocks the GetNamespaced method.
	GetNamespacedFunc func(namespace string, name string, opts v1.GetOptions) (*v1beta2.Deployment, error)

	// ListFunc mocks the List method.
	ListFunc func(opts v1.ListOptions) (*v1beta2a.DeploymentList, error)

	// ObjectClientFunc mocks the ObjectClient method.
	ObjectClientFunc func() *objectclient.ObjectClient

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 *v1beta2.Deployment) (*v1beta2.Deployment, error)

	// WatchFunc mocks the Watch method.
	WatchFunc func(opts v1.ListOptions) (watch.Interface, error)
	// contains filtered or unexported fields
}

DeploymentInterfaceMock is a mock implementation of DeploymentInterface.

    func TestSomethingThatUsesDeploymentInterface(t *testing.T) {

        // make and configure a mocked DeploymentInterface
        mockedDeploymentInterface := &DeploymentInterfaceMock{
            AddClusterScopedHandlerFunc: func(ctx context.Context, name string, clusterName string, sync v1beta2a.DeploymentHandlerFunc)  {
	               panic("mock out the AddClusterScopedHandler method")
            },
            AddClusterScopedLifecycleFunc: func(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.DeploymentLifecycle)  {
	               panic("mock out the AddClusterScopedLifecycle method")
            },
            AddHandlerFunc: func(ctx context.Context, name string, sync v1beta2a.DeploymentHandlerFunc)  {
	               panic("mock out the AddHandler method")
            },
            AddLifecycleFunc: func(ctx context.Context, name string, lifecycle v1beta2a.DeploymentLifecycle)  {
	               panic("mock out the AddLifecycle method")
            },
            ControllerFunc: func() v1beta2a.DeploymentController {
	               panic("mock out the Controller method")
            },
            CreateFunc: func(in1 *v1beta2.Deployment) (*v1beta2.Deployment, error) {
	               panic("mock out the Create method")
            },
            DeleteFunc: func(name string, options *v1.DeleteOptions) error {
	               panic("mock out the Delete method")
            },
            DeleteCollectionFunc: func(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error {
	               panic("mock out the DeleteCollection method")
            },
            DeleteNamespacedFunc: func(namespace string, name string, options *v1.DeleteOptions) error {
	               panic("mock out the DeleteNamespaced method")
            },
            GetFunc: func(name string, opts v1.GetOptions) (*v1beta2.Deployment, error) {
	               panic("mock out the Get method")
            },
            GetNamespacedFunc: func(namespace string, name string, opts v1.GetOptions) (*v1beta2.Deployment, error) {
	               panic("mock out the GetNamespaced method")
            },
            ListFunc: func(opts v1.ListOptions) (*v1beta2a.DeploymentList, error) {
	               panic("mock out the List method")
            },
            ObjectClientFunc: func() *objectclient.ObjectClient {
	               panic("mock out the ObjectClient method")
            },
            UpdateFunc: func(in1 *v1beta2.Deployment) (*v1beta2.Deployment, error) {
	               panic("mock out the Update method")
            },
            WatchFunc: func(opts v1.ListOptions) (watch.Interface, error) {
	               panic("mock out the Watch method")
            },
        }

        // use mockedDeploymentInterface in code that requires DeploymentInterface
        // and then make assertions.

    }

func (*DeploymentInterfaceMock) AddClusterScopedHandler

func (mock *DeploymentInterfaceMock) AddClusterScopedHandler(ctx context.Context, name string, clusterName string, sync v1beta2a.DeploymentHandlerFunc)

AddClusterScopedHandler calls AddClusterScopedHandlerFunc.

func (*DeploymentInterfaceMock) AddClusterScopedHandlerCalls

func (mock *DeploymentInterfaceMock) AddClusterScopedHandlerCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Sync        v1beta2a.DeploymentHandlerFunc
}

AddClusterScopedHandlerCalls gets all the calls that were made to AddClusterScopedHandler. Check the length with:

len(mockedDeploymentInterface.AddClusterScopedHandlerCalls())

func (*DeploymentInterfaceMock) AddClusterScopedLifecycle

func (mock *DeploymentInterfaceMock) AddClusterScopedLifecycle(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.DeploymentLifecycle)

AddClusterScopedLifecycle calls AddClusterScopedLifecycleFunc.

func (*DeploymentInterfaceMock) AddClusterScopedLifecycleCalls

func (mock *DeploymentInterfaceMock) AddClusterScopedLifecycleCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Lifecycle   v1beta2a.DeploymentLifecycle
}

AddClusterScopedLifecycleCalls gets all the calls that were made to AddClusterScopedLifecycle. Check the length with:

len(mockedDeploymentInterface.AddClusterScopedLifecycleCalls())

func (*DeploymentInterfaceMock) AddHandler

func (mock *DeploymentInterfaceMock) AddHandler(ctx context.Context, name string, sync v1beta2a.DeploymentHandlerFunc)

AddHandler calls AddHandlerFunc.

func (*DeploymentInterfaceMock) AddHandlerCalls

func (mock *DeploymentInterfaceMock) AddHandlerCalls() []struct {
	Ctx  context.Context
	Name string
	Sync v1beta2a.DeploymentHandlerFunc
}

AddHandlerCalls gets all the calls that were made to AddHandler. Check the length with:

len(mockedDeploymentInterface.AddHandlerCalls())

func (*DeploymentInterfaceMock) AddLifecycle

func (mock *DeploymentInterfaceMock) AddLifecycle(ctx context.Context, name string, lifecycle v1beta2a.DeploymentLifecycle)

AddLifecycle calls AddLifecycleFunc.

func (*DeploymentInterfaceMock) AddLifecycleCalls

func (mock *DeploymentInterfaceMock) AddLifecycleCalls() []struct {
	Ctx       context.Context
	Name      string
	Lifecycle v1beta2a.DeploymentLifecycle
}

AddLifecycleCalls gets all the calls that were made to AddLifecycle. Check the length with:

len(mockedDeploymentInterface.AddLifecycleCalls())

func (*DeploymentInterfaceMock) Controller

Controller calls ControllerFunc.

func (*DeploymentInterfaceMock) ControllerCalls

func (mock *DeploymentInterfaceMock) ControllerCalls() []struct {
}

ControllerCalls gets all the calls that were made to Controller. Check the length with:

len(mockedDeploymentInterface.ControllerCalls())

func (*DeploymentInterfaceMock) Create

Create calls CreateFunc.

func (*DeploymentInterfaceMock) CreateCalls

func (mock *DeploymentInterfaceMock) CreateCalls() []struct {
	In1 *v1beta2.Deployment
}

CreateCalls gets all the calls that were made to Create. Check the length with:

len(mockedDeploymentInterface.CreateCalls())

func (*DeploymentInterfaceMock) Delete

func (mock *DeploymentInterfaceMock) Delete(name string, options *v1.DeleteOptions) error

Delete calls DeleteFunc.

func (*DeploymentInterfaceMock) DeleteCalls

func (mock *DeploymentInterfaceMock) DeleteCalls() []struct {
	Name    string
	Options *v1.DeleteOptions
}

DeleteCalls gets all the calls that were made to Delete. Check the length with:

len(mockedDeploymentInterface.DeleteCalls())

func (*DeploymentInterfaceMock) DeleteCollection

func (mock *DeploymentInterfaceMock) DeleteCollection(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error

DeleteCollection calls DeleteCollectionFunc.

func (*DeploymentInterfaceMock) DeleteCollectionCalls

func (mock *DeploymentInterfaceMock) DeleteCollectionCalls() []struct {
	DeleteOpts *v1.DeleteOptions
	ListOpts   v1.ListOptions
}

DeleteCollectionCalls gets all the calls that were made to DeleteCollection. Check the length with:

len(mockedDeploymentInterface.DeleteCollectionCalls())

func (*DeploymentInterfaceMock) DeleteNamespaced

func (mock *DeploymentInterfaceMock) DeleteNamespaced(namespace string, name string, options *v1.DeleteOptions) error

DeleteNamespaced calls DeleteNamespacedFunc.

func (*DeploymentInterfaceMock) DeleteNamespacedCalls

func (mock *DeploymentInterfaceMock) DeleteNamespacedCalls() []struct {
	Namespace string
	Name      string
	Options   *v1.DeleteOptions
}

DeleteNamespacedCalls gets all the calls that were made to DeleteNamespaced. Check the length with:

len(mockedDeploymentInterface.DeleteNamespacedCalls())

func (*DeploymentInterfaceMock) Get

Get calls GetFunc.

func (*DeploymentInterfaceMock) GetCalls

func (mock *DeploymentInterfaceMock) GetCalls() []struct {
	Name string
	Opts v1.GetOptions
}

GetCalls gets all the calls that were made to Get. Check the length with:

len(mockedDeploymentInterface.GetCalls())

func (*DeploymentInterfaceMock) GetNamespaced

func (mock *DeploymentInterfaceMock) GetNamespaced(namespace string, name string, opts v1.GetOptions) (*v1beta2.Deployment, error)

GetNamespaced calls GetNamespacedFunc.

func (*DeploymentInterfaceMock) GetNamespacedCalls

func (mock *DeploymentInterfaceMock) GetNamespacedCalls() []struct {
	Namespace string
	Name      string
	Opts      v1.GetOptions
}

GetNamespacedCalls gets all the calls that were made to GetNamespaced. Check the length with:

len(mockedDeploymentInterface.GetNamespacedCalls())

func (*DeploymentInterfaceMock) List

List calls ListFunc.

func (*DeploymentInterfaceMock) ListCalls

func (mock *DeploymentInterfaceMock) ListCalls() []struct {
	Opts v1.ListOptions
}

ListCalls gets all the calls that were made to List. Check the length with:

len(mockedDeploymentInterface.ListCalls())

func (*DeploymentInterfaceMock) ObjectClient

func (mock *DeploymentInterfaceMock) ObjectClient() *objectclient.ObjectClient

ObjectClient calls ObjectClientFunc.

func (*DeploymentInterfaceMock) ObjectClientCalls

func (mock *DeploymentInterfaceMock) ObjectClientCalls() []struct {
}

ObjectClientCalls gets all the calls that were made to ObjectClient. Check the length with:

len(mockedDeploymentInterface.ObjectClientCalls())

func (*DeploymentInterfaceMock) Update

Update calls UpdateFunc.

func (*DeploymentInterfaceMock) UpdateCalls

func (mock *DeploymentInterfaceMock) UpdateCalls() []struct {
	In1 *v1beta2.Deployment
}

UpdateCalls gets all the calls that were made to Update. Check the length with:

len(mockedDeploymentInterface.UpdateCalls())

func (*DeploymentInterfaceMock) Watch

Watch calls WatchFunc.

func (*DeploymentInterfaceMock) WatchCalls

func (mock *DeploymentInterfaceMock) WatchCalls() []struct {
	Opts v1.ListOptions
}

WatchCalls gets all the calls that were made to Watch. Check the length with:

len(mockedDeploymentInterface.WatchCalls())

type DeploymentListerMock

type DeploymentListerMock struct {
	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string) (*v1beta2.Deployment, error)

	// ListFunc mocks the List method.
	ListFunc func(namespace string, selector labels.Selector) ([]*v1beta2.Deployment, error)
	// contains filtered or unexported fields
}

DeploymentListerMock is a mock implementation of DeploymentLister.

    func TestSomethingThatUsesDeploymentLister(t *testing.T) {

        // make and configure a mocked DeploymentLister
        mockedDeploymentLister := &DeploymentListerMock{
            GetFunc: func(namespace string, name string) (*v1beta2.Deployment, error) {
	               panic("mock out the Get method")
            },
            ListFunc: func(namespace string, selector labels.Selector) ([]*v1beta2.Deployment, error) {
	               panic("mock out the List method")
            },
        }

        // use mockedDeploymentLister in code that requires DeploymentLister
        // and then make assertions.

    }

func (*DeploymentListerMock) Get

func (mock *DeploymentListerMock) Get(namespace string, name string) (*v1beta2.Deployment, error)

Get calls GetFunc.

func (*DeploymentListerMock) GetCalls

func (mock *DeploymentListerMock) GetCalls() []struct {
	Namespace string
	Name      string
}

GetCalls gets all the calls that were made to Get. Check the length with:

len(mockedDeploymentLister.GetCalls())

func (*DeploymentListerMock) List

func (mock *DeploymentListerMock) List(namespace string, selector labels.Selector) ([]*v1beta2.Deployment, error)

List calls ListFunc.

func (*DeploymentListerMock) ListCalls

func (mock *DeploymentListerMock) ListCalls() []struct {
	Namespace string
	Selector  labels.Selector
}

ListCalls gets all the calls that were made to List. Check the length with:

len(mockedDeploymentLister.ListCalls())

type DeploymentsGetterMock

type DeploymentsGetterMock struct {
	// DeploymentsFunc mocks the Deployments method.
	DeploymentsFunc func(namespace string) v1beta2a.DeploymentInterface
	// contains filtered or unexported fields
}

DeploymentsGetterMock is a mock implementation of DeploymentsGetter.

    func TestSomethingThatUsesDeploymentsGetter(t *testing.T) {

        // make and configure a mocked DeploymentsGetter
        mockedDeploymentsGetter := &DeploymentsGetterMock{
            DeploymentsFunc: func(namespace string) v1beta2a.DeploymentInterface {
	               panic("mock out the Deployments method")
            },
        }

        // use mockedDeploymentsGetter in code that requires DeploymentsGetter
        // and then make assertions.

    }

func (*DeploymentsGetterMock) Deployments

func (mock *DeploymentsGetterMock) Deployments(namespace string) v1beta2a.DeploymentInterface

Deployments calls DeploymentsFunc.

func (*DeploymentsGetterMock) DeploymentsCalls

func (mock *DeploymentsGetterMock) DeploymentsCalls() []struct {
	Namespace string
}

DeploymentsCalls gets all the calls that were made to Deployments. Check the length with:

len(mockedDeploymentsGetter.DeploymentsCalls())

type ReplicaSetControllerMock

type ReplicaSetControllerMock struct {
	// AddClusterScopedHandlerFunc mocks the AddClusterScopedHandler method.
	AddClusterScopedHandlerFunc func(ctx context.Context, name string, clusterName string, handler v1beta2a.ReplicaSetHandlerFunc)

	// AddHandlerFunc mocks the AddHandler method.
	AddHandlerFunc func(ctx context.Context, name string, handler v1beta2a.ReplicaSetHandlerFunc)

	// EnqueueFunc mocks the Enqueue method.
	EnqueueFunc func(namespace string, name string)

	// GenericFunc mocks the Generic method.
	GenericFunc func() controller.GenericController

	// InformerFunc mocks the Informer method.
	InformerFunc func() cache.SharedIndexInformer

	// ListerFunc mocks the Lister method.
	ListerFunc func() v1beta2a.ReplicaSetLister

	// StartFunc mocks the Start method.
	StartFunc func(ctx context.Context, threadiness int) error

	// SyncFunc mocks the Sync method.
	SyncFunc func(ctx context.Context) error
	// contains filtered or unexported fields
}

ReplicaSetControllerMock is a mock implementation of ReplicaSetController.

    func TestSomethingThatUsesReplicaSetController(t *testing.T) {

        // make and configure a mocked ReplicaSetController
        mockedReplicaSetController := &ReplicaSetControllerMock{
            AddClusterScopedHandlerFunc: func(ctx context.Context, name string, clusterName string, handler v1beta2a.ReplicaSetHandlerFunc)  {
	               panic("mock out the AddClusterScopedHandler method")
            },
            AddHandlerFunc: func(ctx context.Context, name string, handler v1beta2a.ReplicaSetHandlerFunc)  {
	               panic("mock out the AddHandler method")
            },
            EnqueueFunc: func(namespace string, name string)  {
	               panic("mock out the Enqueue method")
            },
            GenericFunc: func() controller.GenericController {
	               panic("mock out the Generic method")
            },
            InformerFunc: func() cache.SharedIndexInformer {
	               panic("mock out the Informer method")
            },
            ListerFunc: func() v1beta2a.ReplicaSetLister {
	               panic("mock out the Lister method")
            },
            StartFunc: func(ctx context.Context, threadiness int) error {
	               panic("mock out the Start method")
            },
            SyncFunc: func(ctx context.Context) error {
	               panic("mock out the Sync method")
            },
        }

        // use mockedReplicaSetController in code that requires ReplicaSetController
        // and then make assertions.

    }

func (*ReplicaSetControllerMock) AddClusterScopedHandler

func (mock *ReplicaSetControllerMock) AddClusterScopedHandler(ctx context.Context, name string, clusterName string, handler v1beta2a.ReplicaSetHandlerFunc)

AddClusterScopedHandler calls AddClusterScopedHandlerFunc.

func (*ReplicaSetControllerMock) AddClusterScopedHandlerCalls

func (mock *ReplicaSetControllerMock) AddClusterScopedHandlerCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Handler     v1beta2a.ReplicaSetHandlerFunc
}

AddClusterScopedHandlerCalls gets all the calls that were made to AddClusterScopedHandler. Check the length with:

len(mockedReplicaSetController.AddClusterScopedHandlerCalls())

func (*ReplicaSetControllerMock) AddHandler

func (mock *ReplicaSetControllerMock) AddHandler(ctx context.Context, name string, handler v1beta2a.ReplicaSetHandlerFunc)

AddHandler calls AddHandlerFunc.

func (*ReplicaSetControllerMock) AddHandlerCalls

func (mock *ReplicaSetControllerMock) AddHandlerCalls() []struct {
	Ctx     context.Context
	Name    string
	Handler v1beta2a.ReplicaSetHandlerFunc
}

AddHandlerCalls gets all the calls that were made to AddHandler. Check the length with:

len(mockedReplicaSetController.AddHandlerCalls())

func (*ReplicaSetControllerMock) Enqueue

func (mock *ReplicaSetControllerMock) Enqueue(namespace string, name string)

Enqueue calls EnqueueFunc.

func (*ReplicaSetControllerMock) EnqueueCalls

func (mock *ReplicaSetControllerMock) EnqueueCalls() []struct {
	Namespace string
	Name      string
}

EnqueueCalls gets all the calls that were made to Enqueue. Check the length with:

len(mockedReplicaSetController.EnqueueCalls())

func (*ReplicaSetControllerMock) Generic

Generic calls GenericFunc.

func (*ReplicaSetControllerMock) GenericCalls

func (mock *ReplicaSetControllerMock) GenericCalls() []struct {
}

GenericCalls gets all the calls that were made to Generic. Check the length with:

len(mockedReplicaSetController.GenericCalls())

func (*ReplicaSetControllerMock) Informer

Informer calls InformerFunc.

func (*ReplicaSetControllerMock) InformerCalls

func (mock *ReplicaSetControllerMock) InformerCalls() []struct {
}

InformerCalls gets all the calls that were made to Informer. Check the length with:

len(mockedReplicaSetController.InformerCalls())

func (*ReplicaSetControllerMock) Lister

Lister calls ListerFunc.

func (*ReplicaSetControllerMock) ListerCalls

func (mock *ReplicaSetControllerMock) ListerCalls() []struct {
}

ListerCalls gets all the calls that were made to Lister. Check the length with:

len(mockedReplicaSetController.ListerCalls())

func (*ReplicaSetControllerMock) Start

func (mock *ReplicaSetControllerMock) Start(ctx context.Context, threadiness int) error

Start calls StartFunc.

func (*ReplicaSetControllerMock) StartCalls

func (mock *ReplicaSetControllerMock) StartCalls() []struct {
	Ctx         context.Context
	Threadiness int
}

StartCalls gets all the calls that were made to Start. Check the length with:

len(mockedReplicaSetController.StartCalls())

func (*ReplicaSetControllerMock) Sync

Sync calls SyncFunc.

func (*ReplicaSetControllerMock) SyncCalls

func (mock *ReplicaSetControllerMock) SyncCalls() []struct {
	Ctx context.Context
}

SyncCalls gets all the calls that were made to Sync. Check the length with:

len(mockedReplicaSetController.SyncCalls())

type ReplicaSetInterfaceMock

type ReplicaSetInterfaceMock struct {
	// AddClusterScopedHandlerFunc mocks the AddClusterScopedHandler method.
	AddClusterScopedHandlerFunc func(ctx context.Context, name string, clusterName string, sync v1beta2a.ReplicaSetHandlerFunc)

	// AddClusterScopedLifecycleFunc mocks the AddClusterScopedLifecycle method.
	AddClusterScopedLifecycleFunc func(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.ReplicaSetLifecycle)

	// AddHandlerFunc mocks the AddHandler method.
	AddHandlerFunc func(ctx context.Context, name string, sync v1beta2a.ReplicaSetHandlerFunc)

	// AddLifecycleFunc mocks the AddLifecycle method.
	AddLifecycleFunc func(ctx context.Context, name string, lifecycle v1beta2a.ReplicaSetLifecycle)

	// ControllerFunc mocks the Controller method.
	ControllerFunc func() v1beta2a.ReplicaSetController

	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error)

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(name string, options *v1.DeleteOptions) error

	// DeleteCollectionFunc mocks the DeleteCollection method.
	DeleteCollectionFunc func(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error

	// DeleteNamespacedFunc mocks the DeleteNamespaced method.
	DeleteNamespacedFunc func(namespace string, name string, options *v1.DeleteOptions) error

	// GetFunc mocks the Get method.
	GetFunc func(name string, opts v1.GetOptions) (*v1beta2.ReplicaSet, error)

	// GetNamespacedFunc mocks the GetNamespaced method.
	GetNamespacedFunc func(namespace string, name string, opts v1.GetOptions) (*v1beta2.ReplicaSet, error)

	// ListFunc mocks the List method.
	ListFunc func(opts v1.ListOptions) (*v1beta2a.ReplicaSetList, error)

	// ObjectClientFunc mocks the ObjectClient method.
	ObjectClientFunc func() *objectclient.ObjectClient

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error)

	// WatchFunc mocks the Watch method.
	WatchFunc func(opts v1.ListOptions) (watch.Interface, error)
	// contains filtered or unexported fields
}

ReplicaSetInterfaceMock is a mock implementation of ReplicaSetInterface.

    func TestSomethingThatUsesReplicaSetInterface(t *testing.T) {

        // make and configure a mocked ReplicaSetInterface
        mockedReplicaSetInterface := &ReplicaSetInterfaceMock{
            AddClusterScopedHandlerFunc: func(ctx context.Context, name string, clusterName string, sync v1beta2a.ReplicaSetHandlerFunc)  {
	               panic("mock out the AddClusterScopedHandler method")
            },
            AddClusterScopedLifecycleFunc: func(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.ReplicaSetLifecycle)  {
	               panic("mock out the AddClusterScopedLifecycle method")
            },
            AddHandlerFunc: func(ctx context.Context, name string, sync v1beta2a.ReplicaSetHandlerFunc)  {
	               panic("mock out the AddHandler method")
            },
            AddLifecycleFunc: func(ctx context.Context, name string, lifecycle v1beta2a.ReplicaSetLifecycle)  {
	               panic("mock out the AddLifecycle method")
            },
            ControllerFunc: func() v1beta2a.ReplicaSetController {
	               panic("mock out the Controller method")
            },
            CreateFunc: func(in1 *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) {
	               panic("mock out the Create method")
            },
            DeleteFunc: func(name string, options *v1.DeleteOptions) error {
	               panic("mock out the Delete method")
            },
            DeleteCollectionFunc: func(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error {
	               panic("mock out the DeleteCollection method")
            },
            DeleteNamespacedFunc: func(namespace string, name string, options *v1.DeleteOptions) error {
	               panic("mock out the DeleteNamespaced method")
            },
            GetFunc: func(name string, opts v1.GetOptions) (*v1beta2.ReplicaSet, error) {
	               panic("mock out the Get method")
            },
            GetNamespacedFunc: func(namespace string, name string, opts v1.GetOptions) (*v1beta2.ReplicaSet, error) {
	               panic("mock out the GetNamespaced method")
            },
            ListFunc: func(opts v1.ListOptions) (*v1beta2a.ReplicaSetList, error) {
	               panic("mock out the List method")
            },
            ObjectClientFunc: func() *objectclient.ObjectClient {
	               panic("mock out the ObjectClient method")
            },
            UpdateFunc: func(in1 *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) {
	               panic("mock out the Update method")
            },
            WatchFunc: func(opts v1.ListOptions) (watch.Interface, error) {
	               panic("mock out the Watch method")
            },
        }

        // use mockedReplicaSetInterface in code that requires ReplicaSetInterface
        // and then make assertions.

    }

func (*ReplicaSetInterfaceMock) AddClusterScopedHandler

func (mock *ReplicaSetInterfaceMock) AddClusterScopedHandler(ctx context.Context, name string, clusterName string, sync v1beta2a.ReplicaSetHandlerFunc)

AddClusterScopedHandler calls AddClusterScopedHandlerFunc.

func (*ReplicaSetInterfaceMock) AddClusterScopedHandlerCalls

func (mock *ReplicaSetInterfaceMock) AddClusterScopedHandlerCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Sync        v1beta2a.ReplicaSetHandlerFunc
}

AddClusterScopedHandlerCalls gets all the calls that were made to AddClusterScopedHandler. Check the length with:

len(mockedReplicaSetInterface.AddClusterScopedHandlerCalls())

func (*ReplicaSetInterfaceMock) AddClusterScopedLifecycle

func (mock *ReplicaSetInterfaceMock) AddClusterScopedLifecycle(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.ReplicaSetLifecycle)

AddClusterScopedLifecycle calls AddClusterScopedLifecycleFunc.

func (*ReplicaSetInterfaceMock) AddClusterScopedLifecycleCalls

func (mock *ReplicaSetInterfaceMock) AddClusterScopedLifecycleCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Lifecycle   v1beta2a.ReplicaSetLifecycle
}

AddClusterScopedLifecycleCalls gets all the calls that were made to AddClusterScopedLifecycle. Check the length with:

len(mockedReplicaSetInterface.AddClusterScopedLifecycleCalls())

func (*ReplicaSetInterfaceMock) AddHandler

func (mock *ReplicaSetInterfaceMock) AddHandler(ctx context.Context, name string, sync v1beta2a.ReplicaSetHandlerFunc)

AddHandler calls AddHandlerFunc.

func (*ReplicaSetInterfaceMock) AddHandlerCalls

func (mock *ReplicaSetInterfaceMock) AddHandlerCalls() []struct {
	Ctx  context.Context
	Name string
	Sync v1beta2a.ReplicaSetHandlerFunc
}

AddHandlerCalls gets all the calls that were made to AddHandler. Check the length with:

len(mockedReplicaSetInterface.AddHandlerCalls())

func (*ReplicaSetInterfaceMock) AddLifecycle

func (mock *ReplicaSetInterfaceMock) AddLifecycle(ctx context.Context, name string, lifecycle v1beta2a.ReplicaSetLifecycle)

AddLifecycle calls AddLifecycleFunc.

func (*ReplicaSetInterfaceMock) AddLifecycleCalls

func (mock *ReplicaSetInterfaceMock) AddLifecycleCalls() []struct {
	Ctx       context.Context
	Name      string
	Lifecycle v1beta2a.ReplicaSetLifecycle
}

AddLifecycleCalls gets all the calls that were made to AddLifecycle. Check the length with:

len(mockedReplicaSetInterface.AddLifecycleCalls())

func (*ReplicaSetInterfaceMock) Controller

Controller calls ControllerFunc.

func (*ReplicaSetInterfaceMock) ControllerCalls

func (mock *ReplicaSetInterfaceMock) ControllerCalls() []struct {
}

ControllerCalls gets all the calls that were made to Controller. Check the length with:

len(mockedReplicaSetInterface.ControllerCalls())

func (*ReplicaSetInterfaceMock) Create

Create calls CreateFunc.

func (*ReplicaSetInterfaceMock) CreateCalls

func (mock *ReplicaSetInterfaceMock) CreateCalls() []struct {
	In1 *v1beta2.ReplicaSet
}

CreateCalls gets all the calls that were made to Create. Check the length with:

len(mockedReplicaSetInterface.CreateCalls())

func (*ReplicaSetInterfaceMock) Delete

func (mock *ReplicaSetInterfaceMock) Delete(name string, options *v1.DeleteOptions) error

Delete calls DeleteFunc.

func (*ReplicaSetInterfaceMock) DeleteCalls

func (mock *ReplicaSetInterfaceMock) DeleteCalls() []struct {
	Name    string
	Options *v1.DeleteOptions
}

DeleteCalls gets all the calls that were made to Delete. Check the length with:

len(mockedReplicaSetInterface.DeleteCalls())

func (*ReplicaSetInterfaceMock) DeleteCollection

func (mock *ReplicaSetInterfaceMock) DeleteCollection(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error

DeleteCollection calls DeleteCollectionFunc.

func (*ReplicaSetInterfaceMock) DeleteCollectionCalls

func (mock *ReplicaSetInterfaceMock) DeleteCollectionCalls() []struct {
	DeleteOpts *v1.DeleteOptions
	ListOpts   v1.ListOptions
}

DeleteCollectionCalls gets all the calls that were made to DeleteCollection. Check the length with:

len(mockedReplicaSetInterface.DeleteCollectionCalls())

func (*ReplicaSetInterfaceMock) DeleteNamespaced

func (mock *ReplicaSetInterfaceMock) DeleteNamespaced(namespace string, name string, options *v1.DeleteOptions) error

DeleteNamespaced calls DeleteNamespacedFunc.

func (*ReplicaSetInterfaceMock) DeleteNamespacedCalls

func (mock *ReplicaSetInterfaceMock) DeleteNamespacedCalls() []struct {
	Namespace string
	Name      string
	Options   *v1.DeleteOptions
}

DeleteNamespacedCalls gets all the calls that were made to DeleteNamespaced. Check the length with:

len(mockedReplicaSetInterface.DeleteNamespacedCalls())

func (*ReplicaSetInterfaceMock) Get

Get calls GetFunc.

func (*ReplicaSetInterfaceMock) GetCalls

func (mock *ReplicaSetInterfaceMock) GetCalls() []struct {
	Name string
	Opts v1.GetOptions
}

GetCalls gets all the calls that were made to Get. Check the length with:

len(mockedReplicaSetInterface.GetCalls())

func (*ReplicaSetInterfaceMock) GetNamespaced

func (mock *ReplicaSetInterfaceMock) GetNamespaced(namespace string, name string, opts v1.GetOptions) (*v1beta2.ReplicaSet, error)

GetNamespaced calls GetNamespacedFunc.

func (*ReplicaSetInterfaceMock) GetNamespacedCalls

func (mock *ReplicaSetInterfaceMock) GetNamespacedCalls() []struct {
	Namespace string
	Name      string
	Opts      v1.GetOptions
}

GetNamespacedCalls gets all the calls that were made to GetNamespaced. Check the length with:

len(mockedReplicaSetInterface.GetNamespacedCalls())

func (*ReplicaSetInterfaceMock) List

List calls ListFunc.

func (*ReplicaSetInterfaceMock) ListCalls

func (mock *ReplicaSetInterfaceMock) ListCalls() []struct {
	Opts v1.ListOptions
}

ListCalls gets all the calls that were made to List. Check the length with:

len(mockedReplicaSetInterface.ListCalls())

func (*ReplicaSetInterfaceMock) ObjectClient

func (mock *ReplicaSetInterfaceMock) ObjectClient() *objectclient.ObjectClient

ObjectClient calls ObjectClientFunc.

func (*ReplicaSetInterfaceMock) ObjectClientCalls

func (mock *ReplicaSetInterfaceMock) ObjectClientCalls() []struct {
}

ObjectClientCalls gets all the calls that were made to ObjectClient. Check the length with:

len(mockedReplicaSetInterface.ObjectClientCalls())

func (*ReplicaSetInterfaceMock) Update

Update calls UpdateFunc.

func (*ReplicaSetInterfaceMock) UpdateCalls

func (mock *ReplicaSetInterfaceMock) UpdateCalls() []struct {
	In1 *v1beta2.ReplicaSet
}

UpdateCalls gets all the calls that were made to Update. Check the length with:

len(mockedReplicaSetInterface.UpdateCalls())

func (*ReplicaSetInterfaceMock) Watch

Watch calls WatchFunc.

func (*ReplicaSetInterfaceMock) WatchCalls

func (mock *ReplicaSetInterfaceMock) WatchCalls() []struct {
	Opts v1.ListOptions
}

WatchCalls gets all the calls that were made to Watch. Check the length with:

len(mockedReplicaSetInterface.WatchCalls())

type ReplicaSetListerMock

type ReplicaSetListerMock struct {
	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string) (*v1beta2.ReplicaSet, error)

	// ListFunc mocks the List method.
	ListFunc func(namespace string, selector labels.Selector) ([]*v1beta2.ReplicaSet, error)
	// contains filtered or unexported fields
}

ReplicaSetListerMock is a mock implementation of ReplicaSetLister.

    func TestSomethingThatUsesReplicaSetLister(t *testing.T) {

        // make and configure a mocked ReplicaSetLister
        mockedReplicaSetLister := &ReplicaSetListerMock{
            GetFunc: func(namespace string, name string) (*v1beta2.ReplicaSet, error) {
	               panic("mock out the Get method")
            },
            ListFunc: func(namespace string, selector labels.Selector) ([]*v1beta2.ReplicaSet, error) {
	               panic("mock out the List method")
            },
        }

        // use mockedReplicaSetLister in code that requires ReplicaSetLister
        // and then make assertions.

    }

func (*ReplicaSetListerMock) Get

func (mock *ReplicaSetListerMock) Get(namespace string, name string) (*v1beta2.ReplicaSet, error)

Get calls GetFunc.

func (*ReplicaSetListerMock) GetCalls

func (mock *ReplicaSetListerMock) GetCalls() []struct {
	Namespace string
	Name      string
}

GetCalls gets all the calls that were made to Get. Check the length with:

len(mockedReplicaSetLister.GetCalls())

func (*ReplicaSetListerMock) List

func (mock *ReplicaSetListerMock) List(namespace string, selector labels.Selector) ([]*v1beta2.ReplicaSet, error)

List calls ListFunc.

func (*ReplicaSetListerMock) ListCalls

func (mock *ReplicaSetListerMock) ListCalls() []struct {
	Namespace string
	Selector  labels.Selector
}

ListCalls gets all the calls that were made to List. Check the length with:

len(mockedReplicaSetLister.ListCalls())

type ReplicaSetsGetterMock

type ReplicaSetsGetterMock struct {
	// ReplicaSetsFunc mocks the ReplicaSets method.
	ReplicaSetsFunc func(namespace string) v1beta2a.ReplicaSetInterface
	// contains filtered or unexported fields
}

ReplicaSetsGetterMock is a mock implementation of ReplicaSetsGetter.

    func TestSomethingThatUsesReplicaSetsGetter(t *testing.T) {

        // make and configure a mocked ReplicaSetsGetter
        mockedReplicaSetsGetter := &ReplicaSetsGetterMock{
            ReplicaSetsFunc: func(namespace string) v1beta2a.ReplicaSetInterface {
	               panic("mock out the ReplicaSets method")
            },
        }

        // use mockedReplicaSetsGetter in code that requires ReplicaSetsGetter
        // and then make assertions.

    }

func (*ReplicaSetsGetterMock) ReplicaSets

func (mock *ReplicaSetsGetterMock) ReplicaSets(namespace string) v1beta2a.ReplicaSetInterface

ReplicaSets calls ReplicaSetsFunc.

func (*ReplicaSetsGetterMock) ReplicaSetsCalls

func (mock *ReplicaSetsGetterMock) ReplicaSetsCalls() []struct {
	Namespace string
}

ReplicaSetsCalls gets all the calls that were made to ReplicaSets. Check the length with:

len(mockedReplicaSetsGetter.ReplicaSetsCalls())

type StatefulSetControllerMock

type StatefulSetControllerMock struct {
	// AddClusterScopedHandlerFunc mocks the AddClusterScopedHandler method.
	AddClusterScopedHandlerFunc func(ctx context.Context, name string, clusterName string, handler v1beta2a.StatefulSetHandlerFunc)

	// AddHandlerFunc mocks the AddHandler method.
	AddHandlerFunc func(ctx context.Context, name string, handler v1beta2a.StatefulSetHandlerFunc)

	// EnqueueFunc mocks the Enqueue method.
	EnqueueFunc func(namespace string, name string)

	// GenericFunc mocks the Generic method.
	GenericFunc func() controller.GenericController

	// InformerFunc mocks the Informer method.
	InformerFunc func() cache.SharedIndexInformer

	// ListerFunc mocks the Lister method.
	ListerFunc func() v1beta2a.StatefulSetLister

	// StartFunc mocks the Start method.
	StartFunc func(ctx context.Context, threadiness int) error

	// SyncFunc mocks the Sync method.
	SyncFunc func(ctx context.Context) error
	// contains filtered or unexported fields
}

StatefulSetControllerMock is a mock implementation of StatefulSetController.

    func TestSomethingThatUsesStatefulSetController(t *testing.T) {

        // make and configure a mocked StatefulSetController
        mockedStatefulSetController := &StatefulSetControllerMock{
            AddClusterScopedHandlerFunc: func(ctx context.Context, name string, clusterName string, handler v1beta2a.StatefulSetHandlerFunc)  {
	               panic("mock out the AddClusterScopedHandler method")
            },
            AddHandlerFunc: func(ctx context.Context, name string, handler v1beta2a.StatefulSetHandlerFunc)  {
	               panic("mock out the AddHandler method")
            },
            EnqueueFunc: func(namespace string, name string)  {
	               panic("mock out the Enqueue method")
            },
            GenericFunc: func() controller.GenericController {
	               panic("mock out the Generic method")
            },
            InformerFunc: func() cache.SharedIndexInformer {
	               panic("mock out the Informer method")
            },
            ListerFunc: func() v1beta2a.StatefulSetLister {
	               panic("mock out the Lister method")
            },
            StartFunc: func(ctx context.Context, threadiness int) error {
	               panic("mock out the Start method")
            },
            SyncFunc: func(ctx context.Context) error {
	               panic("mock out the Sync method")
            },
        }

        // use mockedStatefulSetController in code that requires StatefulSetController
        // and then make assertions.

    }

func (*StatefulSetControllerMock) AddClusterScopedHandler

func (mock *StatefulSetControllerMock) AddClusterScopedHandler(ctx context.Context, name string, clusterName string, handler v1beta2a.StatefulSetHandlerFunc)

AddClusterScopedHandler calls AddClusterScopedHandlerFunc.

func (*StatefulSetControllerMock) AddClusterScopedHandlerCalls

func (mock *StatefulSetControllerMock) AddClusterScopedHandlerCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Handler     v1beta2a.StatefulSetHandlerFunc
}

AddClusterScopedHandlerCalls gets all the calls that were made to AddClusterScopedHandler. Check the length with:

len(mockedStatefulSetController.AddClusterScopedHandlerCalls())

func (*StatefulSetControllerMock) AddHandler

func (mock *StatefulSetControllerMock) AddHandler(ctx context.Context, name string, handler v1beta2a.StatefulSetHandlerFunc)

AddHandler calls AddHandlerFunc.

func (*StatefulSetControllerMock) AddHandlerCalls

func (mock *StatefulSetControllerMock) AddHandlerCalls() []struct {
	Ctx     context.Context
	Name    string
	Handler v1beta2a.StatefulSetHandlerFunc
}

AddHandlerCalls gets all the calls that were made to AddHandler. Check the length with:

len(mockedStatefulSetController.AddHandlerCalls())

func (*StatefulSetControllerMock) Enqueue

func (mock *StatefulSetControllerMock) Enqueue(namespace string, name string)

Enqueue calls EnqueueFunc.

func (*StatefulSetControllerMock) EnqueueCalls

func (mock *StatefulSetControllerMock) EnqueueCalls() []struct {
	Namespace string
	Name      string
}

EnqueueCalls gets all the calls that were made to Enqueue. Check the length with:

len(mockedStatefulSetController.EnqueueCalls())

func (*StatefulSetControllerMock) Generic

Generic calls GenericFunc.

func (*StatefulSetControllerMock) GenericCalls

func (mock *StatefulSetControllerMock) GenericCalls() []struct {
}

GenericCalls gets all the calls that were made to Generic. Check the length with:

len(mockedStatefulSetController.GenericCalls())

func (*StatefulSetControllerMock) Informer

Informer calls InformerFunc.

func (*StatefulSetControllerMock) InformerCalls

func (mock *StatefulSetControllerMock) InformerCalls() []struct {
}

InformerCalls gets all the calls that were made to Informer. Check the length with:

len(mockedStatefulSetController.InformerCalls())

func (*StatefulSetControllerMock) Lister

Lister calls ListerFunc.

func (*StatefulSetControllerMock) ListerCalls

func (mock *StatefulSetControllerMock) ListerCalls() []struct {
}

ListerCalls gets all the calls that were made to Lister. Check the length with:

len(mockedStatefulSetController.ListerCalls())

func (*StatefulSetControllerMock) Start

func (mock *StatefulSetControllerMock) Start(ctx context.Context, threadiness int) error

Start calls StartFunc.

func (*StatefulSetControllerMock) StartCalls

func (mock *StatefulSetControllerMock) StartCalls() []struct {
	Ctx         context.Context
	Threadiness int
}

StartCalls gets all the calls that were made to Start. Check the length with:

len(mockedStatefulSetController.StartCalls())

func (*StatefulSetControllerMock) Sync

Sync calls SyncFunc.

func (*StatefulSetControllerMock) SyncCalls

func (mock *StatefulSetControllerMock) SyncCalls() []struct {
	Ctx context.Context
}

SyncCalls gets all the calls that were made to Sync. Check the length with:

len(mockedStatefulSetController.SyncCalls())

type StatefulSetInterfaceMock

type StatefulSetInterfaceMock struct {
	// AddClusterScopedHandlerFunc mocks the AddClusterScopedHandler method.
	AddClusterScopedHandlerFunc func(ctx context.Context, name string, clusterName string, sync v1beta2a.StatefulSetHandlerFunc)

	// AddClusterScopedLifecycleFunc mocks the AddClusterScopedLifecycle method.
	AddClusterScopedLifecycleFunc func(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.StatefulSetLifecycle)

	// AddHandlerFunc mocks the AddHandler method.
	AddHandlerFunc func(ctx context.Context, name string, sync v1beta2a.StatefulSetHandlerFunc)

	// AddLifecycleFunc mocks the AddLifecycle method.
	AddLifecycleFunc func(ctx context.Context, name string, lifecycle v1beta2a.StatefulSetLifecycle)

	// ControllerFunc mocks the Controller method.
	ControllerFunc func() v1beta2a.StatefulSetController

	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1beta2.StatefulSet) (*v1beta2.StatefulSet, error)

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(name string, options *v1.DeleteOptions) error

	// DeleteCollectionFunc mocks the DeleteCollection method.
	DeleteCollectionFunc func(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error

	// DeleteNamespacedFunc mocks the DeleteNamespaced method.
	DeleteNamespacedFunc func(namespace string, name string, options *v1.DeleteOptions) error

	// GetFunc mocks the Get method.
	GetFunc func(name string, opts v1.GetOptions) (*v1beta2.StatefulSet, error)

	// GetNamespacedFunc mocks the GetNamespaced method.
	GetNamespacedFunc func(namespace string, name string, opts v1.GetOptions) (*v1beta2.StatefulSet, error)

	// ListFunc mocks the List method.
	ListFunc func(opts v1.ListOptions) (*v1beta2a.StatefulSetList, error)

	// ObjectClientFunc mocks the ObjectClient method.
	ObjectClientFunc func() *objectclient.ObjectClient

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 *v1beta2.StatefulSet) (*v1beta2.StatefulSet, error)

	// WatchFunc mocks the Watch method.
	WatchFunc func(opts v1.ListOptions) (watch.Interface, error)
	// contains filtered or unexported fields
}

StatefulSetInterfaceMock is a mock implementation of StatefulSetInterface.

    func TestSomethingThatUsesStatefulSetInterface(t *testing.T) {

        // make and configure a mocked StatefulSetInterface
        mockedStatefulSetInterface := &StatefulSetInterfaceMock{
            AddClusterScopedHandlerFunc: func(ctx context.Context, name string, clusterName string, sync v1beta2a.StatefulSetHandlerFunc)  {
	               panic("mock out the AddClusterScopedHandler method")
            },
            AddClusterScopedLifecycleFunc: func(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.StatefulSetLifecycle)  {
	               panic("mock out the AddClusterScopedLifecycle method")
            },
            AddHandlerFunc: func(ctx context.Context, name string, sync v1beta2a.StatefulSetHandlerFunc)  {
	               panic("mock out the AddHandler method")
            },
            AddLifecycleFunc: func(ctx context.Context, name string, lifecycle v1beta2a.StatefulSetLifecycle)  {
	               panic("mock out the AddLifecycle method")
            },
            ControllerFunc: func() v1beta2a.StatefulSetController {
	               panic("mock out the Controller method")
            },
            CreateFunc: func(in1 *v1beta2.StatefulSet) (*v1beta2.StatefulSet, error) {
	               panic("mock out the Create method")
            },
            DeleteFunc: func(name string, options *v1.DeleteOptions) error {
	               panic("mock out the Delete method")
            },
            DeleteCollectionFunc: func(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error {
	               panic("mock out the DeleteCollection method")
            },
            DeleteNamespacedFunc: func(namespace string, name string, options *v1.DeleteOptions) error {
	               panic("mock out the DeleteNamespaced method")
            },
            GetFunc: func(name string, opts v1.GetOptions) (*v1beta2.StatefulSet, error) {
	               panic("mock out the Get method")
            },
            GetNamespacedFunc: func(namespace string, name string, opts v1.GetOptions) (*v1beta2.StatefulSet, error) {
	               panic("mock out the GetNamespaced method")
            },
            ListFunc: func(opts v1.ListOptions) (*v1beta2a.StatefulSetList, error) {
	               panic("mock out the List method")
            },
            ObjectClientFunc: func() *objectclient.ObjectClient {
	               panic("mock out the ObjectClient method")
            },
            UpdateFunc: func(in1 *v1beta2.StatefulSet) (*v1beta2.StatefulSet, error) {
	               panic("mock out the Update method")
            },
            WatchFunc: func(opts v1.ListOptions) (watch.Interface, error) {
	               panic("mock out the Watch method")
            },
        }

        // use mockedStatefulSetInterface in code that requires StatefulSetInterface
        // and then make assertions.

    }

func (*StatefulSetInterfaceMock) AddClusterScopedHandler

func (mock *StatefulSetInterfaceMock) AddClusterScopedHandler(ctx context.Context, name string, clusterName string, sync v1beta2a.StatefulSetHandlerFunc)

AddClusterScopedHandler calls AddClusterScopedHandlerFunc.

func (*StatefulSetInterfaceMock) AddClusterScopedHandlerCalls

func (mock *StatefulSetInterfaceMock) AddClusterScopedHandlerCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Sync        v1beta2a.StatefulSetHandlerFunc
}

AddClusterScopedHandlerCalls gets all the calls that were made to AddClusterScopedHandler. Check the length with:

len(mockedStatefulSetInterface.AddClusterScopedHandlerCalls())

func (*StatefulSetInterfaceMock) AddClusterScopedLifecycle

func (mock *StatefulSetInterfaceMock) AddClusterScopedLifecycle(ctx context.Context, name string, clusterName string, lifecycle v1beta2a.StatefulSetLifecycle)

AddClusterScopedLifecycle calls AddClusterScopedLifecycleFunc.

func (*StatefulSetInterfaceMock) AddClusterScopedLifecycleCalls

func (mock *StatefulSetInterfaceMock) AddClusterScopedLifecycleCalls() []struct {
	Ctx         context.Context
	Name        string
	ClusterName string
	Lifecycle   v1beta2a.StatefulSetLifecycle
}

AddClusterScopedLifecycleCalls gets all the calls that were made to AddClusterScopedLifecycle. Check the length with:

len(mockedStatefulSetInterface.AddClusterScopedLifecycleCalls())

func (*StatefulSetInterfaceMock) AddHandler

AddHandler calls AddHandlerFunc.

func (*StatefulSetInterfaceMock) AddHandlerCalls

func (mock *StatefulSetInterfaceMock) AddHandlerCalls() []struct {
	Ctx  context.Context
	Name string
	Sync v1beta2a.StatefulSetHandlerFunc
}

AddHandlerCalls gets all the calls that were made to AddHandler. Check the length with:

len(mockedStatefulSetInterface.AddHandlerCalls())

func (*StatefulSetInterfaceMock) AddLifecycle

func (mock *StatefulSetInterfaceMock) AddLifecycle(ctx context.Context, name string, lifecycle v1beta2a.StatefulSetLifecycle)

AddLifecycle calls AddLifecycleFunc.

func (*StatefulSetInterfaceMock) AddLifecycleCalls

func (mock *StatefulSetInterfaceMock) AddLifecycleCalls() []struct {
	Ctx       context.Context
	Name      string
	Lifecycle v1beta2a.StatefulSetLifecycle
}

AddLifecycleCalls gets all the calls that were made to AddLifecycle. Check the length with:

len(mockedStatefulSetInterface.AddLifecycleCalls())

func (*StatefulSetInterfaceMock) Controller

Controller calls ControllerFunc.

func (*StatefulSetInterfaceMock) ControllerCalls

func (mock *StatefulSetInterfaceMock) ControllerCalls() []struct {
}

ControllerCalls gets all the calls that were made to Controller. Check the length with:

len(mockedStatefulSetInterface.ControllerCalls())

func (*StatefulSetInterfaceMock) Create

Create calls CreateFunc.

func (*StatefulSetInterfaceMock) CreateCalls

func (mock *StatefulSetInterfaceMock) CreateCalls() []struct {
	In1 *v1beta2.StatefulSet
}

CreateCalls gets all the calls that were made to Create. Check the length with:

len(mockedStatefulSetInterface.CreateCalls())

func (*StatefulSetInterfaceMock) Delete

func (mock *StatefulSetInterfaceMock) Delete(name string, options *v1.DeleteOptions) error

Delete calls DeleteFunc.

func (*StatefulSetInterfaceMock) DeleteCalls

func (mock *StatefulSetInterfaceMock) DeleteCalls() []struct {
	Name    string
	Options *v1.DeleteOptions
}

DeleteCalls gets all the calls that were made to Delete. Check the length with:

len(mockedStatefulSetInterface.DeleteCalls())

func (*StatefulSetInterfaceMock) DeleteCollection

func (mock *StatefulSetInterfaceMock) DeleteCollection(deleteOpts *v1.DeleteOptions, listOpts v1.ListOptions) error

DeleteCollection calls DeleteCollectionFunc.

func (*StatefulSetInterfaceMock) DeleteCollectionCalls

func (mock *StatefulSetInterfaceMock) DeleteCollectionCalls() []struct {
	DeleteOpts *v1.DeleteOptions
	ListOpts   v1.ListOptions
}

DeleteCollectionCalls gets all the calls that were made to DeleteCollection. Check the length with:

len(mockedStatefulSetInterface.DeleteCollectionCalls())

func (*StatefulSetInterfaceMock) DeleteNamespaced

func (mock *StatefulSetInterfaceMock) DeleteNamespaced(namespace string, name string, options *v1.DeleteOptions) error

DeleteNamespaced calls DeleteNamespacedFunc.

func (*StatefulSetInterfaceMock) DeleteNamespacedCalls

func (mock *StatefulSetInterfaceMock) DeleteNamespacedCalls() []struct {
	Namespace string
	Name      string
	Options   *v1.DeleteOptions
}

DeleteNamespacedCalls gets all the calls that were made to DeleteNamespaced. Check the length with:

len(mockedStatefulSetInterface.DeleteNamespacedCalls())

func (*StatefulSetInterfaceMock) Get

Get calls GetFunc.

func (*StatefulSetInterfaceMock) GetCalls

func (mock *StatefulSetInterfaceMock) GetCalls() []struct {
	Name string
	Opts v1.GetOptions
}

GetCalls gets all the calls that were made to Get. Check the length with:

len(mockedStatefulSetInterface.GetCalls())

func (*StatefulSetInterfaceMock) GetNamespaced

func (mock *StatefulSetInterfaceMock) GetNamespaced(namespace string, name string, opts v1.GetOptions) (*v1beta2.StatefulSet, error)

GetNamespaced calls GetNamespacedFunc.

func (*StatefulSetInterfaceMock) GetNamespacedCalls

func (mock *StatefulSetInterfaceMock) GetNamespacedCalls() []struct {
	Namespace string
	Name      string
	Opts      v1.GetOptions
}

GetNamespacedCalls gets all the calls that were made to GetNamespaced. Check the length with:

len(mockedStatefulSetInterface.GetNamespacedCalls())

func (*StatefulSetInterfaceMock) List

List calls ListFunc.

func (*StatefulSetInterfaceMock) ListCalls

func (mock *StatefulSetInterfaceMock) ListCalls() []struct {
	Opts v1.ListOptions
}

ListCalls gets all the calls that were made to List. Check the length with:

len(mockedStatefulSetInterface.ListCalls())

func (*StatefulSetInterfaceMock) ObjectClient

func (mock *StatefulSetInterfaceMock) ObjectClient() *objectclient.ObjectClient

ObjectClient calls ObjectClientFunc.

func (*StatefulSetInterfaceMock) ObjectClientCalls

func (mock *StatefulSetInterfaceMock) ObjectClientCalls() []struct {
}

ObjectClientCalls gets all the calls that were made to ObjectClient. Check the length with:

len(mockedStatefulSetInterface.ObjectClientCalls())

func (*StatefulSetInterfaceMock) Update

Update calls UpdateFunc.

func (*StatefulSetInterfaceMock) UpdateCalls

func (mock *StatefulSetInterfaceMock) UpdateCalls() []struct {
	In1 *v1beta2.StatefulSet
}

UpdateCalls gets all the calls that were made to Update. Check the length with:

len(mockedStatefulSetInterface.UpdateCalls())

func (*StatefulSetInterfaceMock) Watch

Watch calls WatchFunc.

func (*StatefulSetInterfaceMock) WatchCalls

func (mock *StatefulSetInterfaceMock) WatchCalls() []struct {
	Opts v1.ListOptions
}

WatchCalls gets all the calls that were made to Watch. Check the length with:

len(mockedStatefulSetInterface.WatchCalls())

type StatefulSetListerMock

type StatefulSetListerMock struct {
	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string) (*v1beta2.StatefulSet, error)

	// ListFunc mocks the List method.
	ListFunc func(namespace string, selector labels.Selector) ([]*v1beta2.StatefulSet, error)
	// contains filtered or unexported fields
}

StatefulSetListerMock is a mock implementation of StatefulSetLister.

    func TestSomethingThatUsesStatefulSetLister(t *testing.T) {

        // make and configure a mocked StatefulSetLister
        mockedStatefulSetLister := &StatefulSetListerMock{
            GetFunc: func(namespace string, name string) (*v1beta2.StatefulSet, error) {
	               panic("mock out the Get method")
            },
            ListFunc: func(namespace string, selector labels.Selector) ([]*v1beta2.StatefulSet, error) {
	               panic("mock out the List method")
            },
        }

        // use mockedStatefulSetLister in code that requires StatefulSetLister
        // and then make assertions.

    }

func (*StatefulSetListerMock) Get

func (mock *StatefulSetListerMock) Get(namespace string, name string) (*v1beta2.StatefulSet, error)

Get calls GetFunc.

func (*StatefulSetListerMock) GetCalls

func (mock *StatefulSetListerMock) GetCalls() []struct {
	Namespace string
	Name      string
}

GetCalls gets all the calls that were made to Get. Check the length with:

len(mockedStatefulSetLister.GetCalls())

func (*StatefulSetListerMock) List

func (mock *StatefulSetListerMock) List(namespace string, selector labels.Selector) ([]*v1beta2.StatefulSet, error)

List calls ListFunc.

func (*StatefulSetListerMock) ListCalls

func (mock *StatefulSetListerMock) ListCalls() []struct {
	Namespace string
	Selector  labels.Selector
}

ListCalls gets all the calls that were made to List. Check the length with:

len(mockedStatefulSetLister.ListCalls())

type StatefulSetsGetterMock

type StatefulSetsGetterMock struct {
	// StatefulSetsFunc mocks the StatefulSets method.
	StatefulSetsFunc func(namespace string) v1beta2a.StatefulSetInterface
	// contains filtered or unexported fields
}

StatefulSetsGetterMock is a mock implementation of StatefulSetsGetter.

    func TestSomethingThatUsesStatefulSetsGetter(t *testing.T) {

        // make and configure a mocked StatefulSetsGetter
        mockedStatefulSetsGetter := &StatefulSetsGetterMock{
            StatefulSetsFunc: func(namespace string) v1beta2a.StatefulSetInterface {
	               panic("mock out the StatefulSets method")
            },
        }

        // use mockedStatefulSetsGetter in code that requires StatefulSetsGetter
        // and then make assertions.

    }

func (*StatefulSetsGetterMock) StatefulSets

func (mock *StatefulSetsGetterMock) StatefulSets(namespace string) v1beta2a.StatefulSetInterface

StatefulSets calls StatefulSetsFunc.

func (*StatefulSetsGetterMock) StatefulSetsCalls

func (mock *StatefulSetsGetterMock) StatefulSetsCalls() []struct {
	Namespace string
}

StatefulSetsCalls gets all the calls that were made to StatefulSets. Check the length with:

len(mockedStatefulSetsGetter.StatefulSetsCalls())

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL