k8s

package
v2.2.13 Latest Latest
Warning

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

 Go to latest Published: May 15, 2026 License: Apache-2.0 Imports: 30 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	IntelMachineResourceSchema = schema.GroupVersionResource{
		Group:    intelProvider.GroupVersion.Group,
		Version:  intelProvider.GroupVersion.Version,
		Resource: "intelmachines",
	}

	DockerMachineResourceSchema = schema.GroupVersionResource{
		Group:    "infrastructure.cluster.x-k8s.io",
		Version:  "v1beta1",
		Resource: "dockermachines",
	}
)

K8s object schemas

View Source 
var ErrClusterNotFound = fmt.Errorf("cluster not found")
View Source 
var ErrDefaultTemplateNotFound = fmt.Errorf("default template not found")

Functions

This section is empty.

Types

type Client 

type Client struct {
	Dyn    dynamic.Interface
	Scheme *runtime.Scheme
}

func New 

func New(dyn ...dynamic.Interface) *Client

func (*Client) AddTemplateLabels 

func (c *Client) AddTemplateLabels(ctx context.Context, namespace string, templateName string, newLabels map[string]string) error

AddTemplateLabels appends new labels on the template object in the given namespace

func (*Client) CreateCluster 

func (c *Client) CreateCluster(ctx context.Context, namespace string, cluster capi.Cluster) (string, error)

CreateCluster creates a new cluster object in the given namespace

func (*Client) CreateMachineBinding 

func (c *Client) CreateMachineBinding(ctx context.Context, namespace string, binding intelProvider.IntelMachineBinding) error

CreateMachineBinding creates a new machine binding object in the given namespace

func (*Client) CreateNamespace 

func (c *Client) CreateNamespace(ctx context.Context, name string) error

CreateNamespace creates a new namespace with the given name

func (*Client) CreateSecret 

func (c *Client) CreateSecret(ctx context.Context, namespace string, name string, data map[string][]byte) error

func (*Client) CreateTemplate 

func (cli *Client) CreateTemplate(ctx context.Context, namespace string, template *v1alpha1.ClusterTemplate) error

CreateTemplate creates a new template object in the given namespace

func (*Client) DefaultTemplate 

func (c *Client) DefaultTemplate(ctx context.Context, namespace string) (v1alpha1.ClusterTemplate, error)

DefaultTemplate returns the default template in the given namespace

func (*Client) DeleteCluster 

func (c *Client) DeleteCluster(ctx context.Context, namespace string, clusterName string) error

DeleteCluster deletes a cluster with the given name in the given namespace

func (*Client) DeleteClusters 

func (c *Client) DeleteClusters(ctx context.Context, namespace string) error

DeleteClusters deletes all clusters in the given namespace

func (*Client) DeleteNamespace 

func (c *Client) DeleteNamespace(ctx context.Context, namespace string) error

DeleteNamespace deletes the namespace with the given name

func (*Client) DeleteTemplates 

func (c *Client) DeleteTemplates(ctx context.Context, namespace string) error

DeleteTemplates deletes all templates in the given namespace

func (*Client) DockerMachine 

func (c *Client) DockerMachine(ctx context.Context, namespace, providerMachineName string) (dockerProvider.DockerMachine, error)

DockerMachine returns the DockerMachine with the given name in the given namespace for the given cluster

func (*Client) DockerMachines 

func (c *Client) DockerMachines(ctx context.Context, namespace, clusterName string) ([]dockerProvider.DockerMachine, error)

DockerMachines returns all DockerMachine objects in the given namespace for the given cluster

func (*Client) GetCluster 

func (c *Client) GetCluster(ctx context.Context, namespace, name string) (*capi.Cluster, error)

GetCluster returns the cluster with the given name in the given namespace

func (*Client) GetClusterTemplate 

func (c *Client) GetClusterTemplate(ctx context.Context, namespace, templateName string) (*v1alpha1.ClusterTemplate, error)

func (*Client) GetMachineByHostID 

func (c *Client) GetMachineByHostID(ctx context.Context, namespace, hostID string) (capi.Machine, error)

GetMachineByHostID returns the machine with the given host ID in the given namespace for the given cluster

func (*Client) GetMachines 

func (c *Client) GetMachines(ctx context.Context, namespace, clusterName string) ([]capi.Machine, error)

GetMachines returns the machine with the given name in the given namespace for the given cluster

func (*Client) HasTemplate 

func (c *Client) HasTemplate(ctx context.Context, namespace, templateName string) bool

func (*Client) IntelMachine 

func (c *Client) IntelMachine(ctx context.Context, namespace, providerMachineName string) (intelProvider.IntelMachine, error)

IntelMachine returns the IntelMachine with the given name in the given namespace for the given cluster

func (*Client) IntelMachines 

func (c *Client) IntelMachines(ctx context.Context, namespace, clusterName string) ([]intelProvider.IntelMachine, error)

IntelMachines returns all IntelMachine objects in the given namespace for the given cluster

func (*Client) RemoveTemplateLabels 

func (c *Client) RemoveTemplateLabels(ctx context.Context, namespace string, templateName string, labelKeys ...string) error

func (*Client) SetClusterLabels 

func (c *Client) SetClusterLabels(ctx context.Context, namespace string, clusterName string, newUserLabels map[string]string) error

SetClusterLabels overrides the labels of the cluster object in the given namespace

func (*Client) SetMachineLabels 

func (c *Client) SetMachineLabels(ctx context.Context, namespace string, machineName string, newUserLabels map[string]string) error

SetMachineLabels overrides the labels of the machine object in the given namespace

func (*Client) Template 

func (c *Client) Template(ctx context.Context, namespace, name string) (v1alpha1.ClusterTemplate, error)

Template returns the template with the given name in the given namespace

func (*Client) Templates 

func (c *Client) Templates(ctx context.Context, namespace string) ([]v1alpha1.ClusterTemplate, error)

Templates returns all templates in the given namespace

func (*Client) WithFakeClient 

func (c *Client) WithFakeClient() *Client

func (*Client) WithInClusterConfig 

func (c *Client) WithInClusterConfig() *Client

type K8sWrapperClient 

type K8sWrapperClient interface {
	GetMachineByHostID(ctx context.Context, namespace, hostID string) (capi.Machine, error)
	DeleteCluster(ctx context.Context, namespace string, clusterName string) error
	SetMachineLabels(ctx context.Context, namespace string, machineName string, newUserLabels map[string]string) error
}

K8sWrapperClient defines the interface for k8s client operations needed by other packages

type MockAPIPathResolverFunc 

type MockAPIPathResolverFunc struct {
	mock.Mock
}

MockAPIPathResolverFunc is an autogenerated mock type for the APIPathResolverFunc type

func NewMockAPIPathResolverFunc 

func NewMockAPIPathResolverFunc(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAPIPathResolverFunc

NewMockAPIPathResolverFunc creates a new instance of MockAPIPathResolverFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockAPIPathResolverFunc) EXPECT 

func (_m *MockAPIPathResolverFunc) EXPECT() *MockAPIPathResolverFunc_Expecter

func (*MockAPIPathResolverFunc) Execute 

func (_m *MockAPIPathResolverFunc) Execute(kind schema.GroupVersionKind) string

Execute provides a mock function with given fields: kind

type MockAPIPathResolverFunc_Execute_Call 

type MockAPIPathResolverFunc_Execute_Call struct {
	*mock.Call
}

MockAPIPathResolverFunc_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'

func (*MockAPIPathResolverFunc_Execute_Call) Return 

func (_c *MockAPIPathResolverFunc_Execute_Call) Return(_a0 string) *MockAPIPathResolverFunc_Execute_Call

func (*MockAPIPathResolverFunc_Execute_Call) Run 

func (_c *MockAPIPathResolverFunc_Execute_Call) Run(run func(kind schema.GroupVersionKind)) *MockAPIPathResolverFunc_Execute_Call

func (*MockAPIPathResolverFunc_Execute_Call) RunAndReturn 

func (_c *MockAPIPathResolverFunc_Execute_Call) RunAndReturn(run func(schema.GroupVersionKind) string) *MockAPIPathResolverFunc_Execute_Call

type MockAPIPathResolverFunc_Expecter 

type MockAPIPathResolverFunc_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockAPIPathResolverFunc_Expecter) Execute 

func (_e *MockAPIPathResolverFunc_Expecter) Execute(kind interface{}) *MockAPIPathResolverFunc_Execute_Call

Execute is a helper method to define mock.On call

  • kind schema.GroupVersionKind

type MockInterface 

type MockInterface struct {
	mock.Mock
}

MockInterface is an autogenerated mock type for the Interface type

func NewMockInterface 

func NewMockInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInterface

NewMockInterface creates a new instance of MockInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInterface) EXPECT 

func (_m *MockInterface) EXPECT() *MockInterface_Expecter

func (*MockInterface) Resource 

func (_m *MockInterface) Resource(resource schema.GroupVersionResource) dynamic.NamespaceableResourceInterface

Resource provides a mock function with given fields: resource

type MockInterface_Expecter 

type MockInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInterface_Expecter) Resource 

func (_e *MockInterface_Expecter) Resource(resource interface{}) *MockInterface_Resource_Call

Resource is a helper method to define mock.On call

  • resource schema.GroupVersionResource

type MockInterface_Resource_Call 

type MockInterface_Resource_Call struct {
	*mock.Call
}

MockInterface_Resource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resource'

func (*MockInterface_Resource_Call) Return 

func (_c *MockInterface_Resource_Call) Return(_a0 dynamic.NamespaceableResourceInterface) *MockInterface_Resource_Call

func (*MockInterface_Resource_Call) Run 

func (_c *MockInterface_Resource_Call) Run(run func(resource schema.GroupVersionResource)) *MockInterface_Resource_Call

func (*MockInterface_Resource_Call) RunAndReturn 

func (_c *MockInterface_Resource_Call) RunAndReturn(run func(schema.GroupVersionResource) dynamic.NamespaceableResourceInterface) *MockInterface_Resource_Call

type MockK8sWrapperClient 

type MockK8sWrapperClient struct {
	mock.Mock
}

MockK8sWrapperClient is an autogenerated mock type for the K8sWrapperClient type

func NewMockK8sWrapperClient 

func NewMockK8sWrapperClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockK8sWrapperClient

NewMockK8sWrapperClient creates a new instance of MockK8sWrapperClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*MockK8sWrapperClient) DeleteCluster 

func (_m *MockK8sWrapperClient) DeleteCluster(ctx context.Context, namespace string, clusterName string) error

DeleteCluster provides a mock function with given fields: ctx, namespace, clusterName

func (*MockK8sWrapperClient) EXPECT 

func (_m *MockK8sWrapperClient) EXPECT() *MockK8sWrapperClient_Expecter

func (*MockK8sWrapperClient) GetMachineByHostID 

func (_m *MockK8sWrapperClient) GetMachineByHostID(ctx context.Context, namespace, hostID string) (capi.Machine, error)

GetMachineByHostID provides a mock function with given fields: ctx, namespace, hostID

func (*MockK8sWrapperClient) SetMachineLabels 

func (_m *MockK8sWrapperClient) SetMachineLabels(ctx context.Context, namespace string, machineName string, newUserLabels map[string]string) error

SetMachineLabels provides a mock function with given fields: ctx, namespace, machineName, newUserLabels

type MockK8sWrapperClient_DeleteCluster_Call 

type MockK8sWrapperClient_DeleteCluster_Call struct {
	*mock.Call
}

MockK8sWrapperClient_DeleteCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCluster'

func (*MockK8sWrapperClient_DeleteCluster_Call) Return 

func (_c *MockK8sWrapperClient_DeleteCluster_Call) Return(_a0 error) *MockK8sWrapperClient_DeleteCluster_Call

func (*MockK8sWrapperClient_DeleteCluster_Call) Run 

func (_c *MockK8sWrapperClient_DeleteCluster_Call) Run(run func(ctx context.Context, namespace string, clusterName string)) *MockK8sWrapperClient_DeleteCluster_Call

func (*MockK8sWrapperClient_DeleteCluster_Call) RunAndReturn 

func (_c *MockK8sWrapperClient_DeleteCluster_Call) RunAndReturn(run func(context.Context, string, string) error) *MockK8sWrapperClient_DeleteCluster_Call

type MockK8sWrapperClient_Expecter 

type MockK8sWrapperClient_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockK8sWrapperClient_Expecter) DeleteCluster 

func (_e *MockK8sWrapperClient_Expecter) DeleteCluster(ctx interface{}, namespace interface{}, clusterName interface{}) *MockK8sWrapperClient_DeleteCluster_Call

DeleteCluster is a helper method to define mock.On call

  • ctx context.Context
  • namespace string
  • clusterName string

func (*MockK8sWrapperClient_Expecter) GetMachineByHostID 

func (_e *MockK8sWrapperClient_Expecter) GetMachineByHostID(ctx interface{}, namespace interface{}, hostID interface{}) *MockK8sWrapperClient_GetMachineByHostID_Call

GetMachineByHostID is a helper method to define mock.On call

  • ctx context.Context
  • namespace string
  • hostID string

func (*MockK8sWrapperClient_Expecter) SetMachineLabels 

func (_e *MockK8sWrapperClient_Expecter) SetMachineLabels(ctx interface{}, namespace interface{}, machineName interface{}, newUserLabels interface{}) *MockK8sWrapperClient_SetMachineLabels_Call

SetMachineLabels is a helper method to define mock.On call

  • ctx context.Context
  • namespace string
  • machineName string
  • newUserLabels map[string]string

type MockK8sWrapperClient_GetMachineByHostID_Call 

type MockK8sWrapperClient_GetMachineByHostID_Call struct {
	*mock.Call
}

MockK8sWrapperClient_GetMachineByHostID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMachineByHostID'

func (*MockK8sWrapperClient_GetMachineByHostID_Call) Return 

func (_c *MockK8sWrapperClient_GetMachineByHostID_Call) Return(_a0 capi.Machine, _a1 error) *MockK8sWrapperClient_GetMachineByHostID_Call

func (*MockK8sWrapperClient_GetMachineByHostID_Call) Run 

func (_c *MockK8sWrapperClient_GetMachineByHostID_Call) Run(run func(ctx context.Context, namespace string, hostID string)) *MockK8sWrapperClient_GetMachineByHostID_Call

func (*MockK8sWrapperClient_GetMachineByHostID_Call) RunAndReturn 

func (_c *MockK8sWrapperClient_GetMachineByHostID_Call) RunAndReturn(run func(context.Context, string, string) (capi.Machine, error)) *MockK8sWrapperClient_GetMachineByHostID_Call

type MockK8sWrapperClient_SetMachineLabels_Call 

type MockK8sWrapperClient_SetMachineLabels_Call struct {
	*mock.Call
}

MockK8sWrapperClient_SetMachineLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMachineLabels'

func (*MockK8sWrapperClient_SetMachineLabels_Call) Return 

func (_c *MockK8sWrapperClient_SetMachineLabels_Call) Return(_a0 error) *MockK8sWrapperClient_SetMachineLabels_Call

func (*MockK8sWrapperClient_SetMachineLabels_Call) Run 

func (_c *MockK8sWrapperClient_SetMachineLabels_Call) Run(run func(ctx context.Context, namespace string, machineName string, newUserLabels map[string]string)) *MockK8sWrapperClient_SetMachineLabels_Call

func (*MockK8sWrapperClient_SetMachineLabels_Call) RunAndReturn 

func (_c *MockK8sWrapperClient_SetMachineLabels_Call) RunAndReturn(run func(context.Context, string, string, map[string]string) error) *MockK8sWrapperClient_SetMachineLabels_Call

type MockNamespaceableResourceInterface 

type MockNamespaceableResourceInterface struct {
	mock.Mock
}

MockNamespaceableResourceInterface is an autogenerated mock type for the NamespaceableResourceInterface type

func NewMockNamespaceableResourceInterface 

func NewMockNamespaceableResourceInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockNamespaceableResourceInterface

NewMockNamespaceableResourceInterface creates a new instance of MockNamespaceableResourceInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockNamespaceableResourceInterface) Apply 

func (_m *MockNamespaceableResourceInterface) Apply(ctx context.Context, name string, obj *unstructured.Unstructured, options v1.ApplyOptions, subresources ...string) (*unstructured.Unstructured, error)

Apply provides a mock function with given fields: ctx, name, obj, options, subresources

func (*MockNamespaceableResourceInterface) ApplyStatus 

func (_m *MockNamespaceableResourceInterface) ApplyStatus(ctx context.Context, name string, obj *unstructured.Unstructured, options v1.ApplyOptions) (*unstructured.Unstructured, error)

ApplyStatus provides a mock function with given fields: ctx, name, obj, options

func (*MockNamespaceableResourceInterface) Create 

func (_m *MockNamespaceableResourceInterface) Create(ctx context.Context, obj *unstructured.Unstructured, options v1.CreateOptions, subresources ...string) (*unstructured.Unstructured, error)

Create provides a mock function with given fields: ctx, obj, options, subresources

func (*MockNamespaceableResourceInterface) Delete 

func (_m *MockNamespaceableResourceInterface) Delete(ctx context.Context, name string, options v1.DeleteOptions, subresources ...string) error

Delete provides a mock function with given fields: ctx, name, options, subresources

func (*MockNamespaceableResourceInterface) DeleteCollection 

func (_m *MockNamespaceableResourceInterface) DeleteCollection(ctx context.Context, options v1.DeleteOptions, listOptions v1.ListOptions) error

DeleteCollection provides a mock function with given fields: ctx, options, listOptions

func (*MockNamespaceableResourceInterface) EXPECT 

func (_m *MockNamespaceableResourceInterface) EXPECT() *MockNamespaceableResourceInterface_Expecter

func (*MockNamespaceableResourceInterface) Get 

func (_m *MockNamespaceableResourceInterface) Get(ctx context.Context, name string, options v1.GetOptions, subresources ...string) (*unstructured.Unstructured, error)

Get provides a mock function with given fields: ctx, name, options, subresources

func (*MockNamespaceableResourceInterface) List 

func (_m *MockNamespaceableResourceInterface) List(ctx context.Context, opts v1.ListOptions) (*unstructured.UnstructuredList, error)

List provides a mock function with given fields: ctx, opts

func (*MockNamespaceableResourceInterface) Namespace 

func (_m *MockNamespaceableResourceInterface) Namespace(_a0 string) dynamic.ResourceInterface

Namespace provides a mock function with given fields: _a0

func (*MockNamespaceableResourceInterface) Patch 

func (_m *MockNamespaceableResourceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, options v1.PatchOptions, subresources ...string) (*unstructured.Unstructured, error)

Patch provides a mock function with given fields: ctx, name, pt, data, options, subresources

func (*MockNamespaceableResourceInterface) Update 

func (_m *MockNamespaceableResourceInterface) Update(ctx context.Context, obj *unstructured.Unstructured, options v1.UpdateOptions, subresources ...string) (*unstructured.Unstructured, error)

Update provides a mock function with given fields: ctx, obj, options, subresources

func (*MockNamespaceableResourceInterface) UpdateStatus 

func (_m *MockNamespaceableResourceInterface) UpdateStatus(ctx context.Context, obj *unstructured.Unstructured, options v1.UpdateOptions) (*unstructured.Unstructured, error)

UpdateStatus provides a mock function with given fields: ctx, obj, options

func (*MockNamespaceableResourceInterface) Watch 

func (_m *MockNamespaceableResourceInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)

Watch provides a mock function with given fields: ctx, opts

type MockNamespaceableResourceInterface_ApplyStatus_Call 

type MockNamespaceableResourceInterface_ApplyStatus_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_ApplyStatus_Call) Return 

func (_c *MockNamespaceableResourceInterface_ApplyStatus_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockNamespaceableResourceInterface_ApplyStatus_Call

func (*MockNamespaceableResourceInterface_ApplyStatus_Call) Run 

func (_c *MockNamespaceableResourceInterface_ApplyStatus_Call) Run(run func(ctx context.Context, name string, obj *unstructured.Unstructured, options v1.ApplyOptions)) *MockNamespaceableResourceInterface_ApplyStatus_Call

func (*MockNamespaceableResourceInterface_ApplyStatus_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_ApplyStatus_Call) RunAndReturn(run func(context.Context, string, *unstructured.Unstructured, v1.ApplyOptions) (*unstructured.Unstructured, error)) *MockNamespaceableResourceInterface_ApplyStatus_Call

type MockNamespaceableResourceInterface_Apply_Call 

type MockNamespaceableResourceInterface_Apply_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_Apply_Call) Return 

func (_c *MockNamespaceableResourceInterface_Apply_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockNamespaceableResourceInterface_Apply_Call

func (*MockNamespaceableResourceInterface_Apply_Call) Run 

func (_c *MockNamespaceableResourceInterface_Apply_Call) Run(run func(ctx context.Context, name string, obj *unstructured.Unstructured, options v1.ApplyOptions, subresources ...string)) *MockNamespaceableResourceInterface_Apply_Call

func (*MockNamespaceableResourceInterface_Apply_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_Apply_Call) RunAndReturn(run func(context.Context, string, *unstructured.Unstructured, v1.ApplyOptions, ...string) (*unstructured.Unstructured, error)) *MockNamespaceableResourceInterface_Apply_Call

type MockNamespaceableResourceInterface_Create_Call 

type MockNamespaceableResourceInterface_Create_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_Create_Call) Return 

func (_c *MockNamespaceableResourceInterface_Create_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockNamespaceableResourceInterface_Create_Call

func (*MockNamespaceableResourceInterface_Create_Call) Run 

func (_c *MockNamespaceableResourceInterface_Create_Call) Run(run func(ctx context.Context, obj *unstructured.Unstructured, options v1.CreateOptions, subresources ...string)) *MockNamespaceableResourceInterface_Create_Call

func (*MockNamespaceableResourceInterface_Create_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_Create_Call) RunAndReturn(run func(context.Context, *unstructured.Unstructured, v1.CreateOptions, ...string) (*unstructured.Unstructured, error)) *MockNamespaceableResourceInterface_Create_Call

type MockNamespaceableResourceInterface_DeleteCollection_Call 

type MockNamespaceableResourceInterface_DeleteCollection_Call struct {
	*mock.Call
}

MockNamespaceableResourceInterface_DeleteCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCollection'

func (*MockNamespaceableResourceInterface_DeleteCollection_Call) Return 

func (_c *MockNamespaceableResourceInterface_DeleteCollection_Call) Return(_a0 error) *MockNamespaceableResourceInterface_DeleteCollection_Call

func (*MockNamespaceableResourceInterface_DeleteCollection_Call) Run 

func (_c *MockNamespaceableResourceInterface_DeleteCollection_Call) Run(run func(ctx context.Context, options v1.DeleteOptions, listOptions v1.ListOptions)) *MockNamespaceableResourceInterface_DeleteCollection_Call

func (*MockNamespaceableResourceInterface_DeleteCollection_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_DeleteCollection_Call) RunAndReturn(run func(context.Context, v1.DeleteOptions, v1.ListOptions) error) *MockNamespaceableResourceInterface_DeleteCollection_Call

type MockNamespaceableResourceInterface_Delete_Call 

type MockNamespaceableResourceInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_Delete_Call) Return 

func (_c *MockNamespaceableResourceInterface_Delete_Call) Return(_a0 error) *MockNamespaceableResourceInterface_Delete_Call

func (*MockNamespaceableResourceInterface_Delete_Call) Run 

func (_c *MockNamespaceableResourceInterface_Delete_Call) Run(run func(ctx context.Context, name string, options v1.DeleteOptions, subresources ...string)) *MockNamespaceableResourceInterface_Delete_Call

func (*MockNamespaceableResourceInterface_Delete_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_Delete_Call) RunAndReturn(run func(context.Context, string, v1.DeleteOptions, ...string) error) *MockNamespaceableResourceInterface_Delete_Call

type MockNamespaceableResourceInterface_Expecter 

type MockNamespaceableResourceInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockNamespaceableResourceInterface_Expecter) Apply 

func (_e *MockNamespaceableResourceInterface_Expecter) Apply(ctx interface{}, name interface{}, obj interface{}, options interface{}, subresources ...interface{}) *MockNamespaceableResourceInterface_Apply_Call

Apply is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • obj *unstructured.Unstructured
  • options v1.ApplyOptions
  • subresources ...string

func (*MockNamespaceableResourceInterface_Expecter) ApplyStatus 

func (_e *MockNamespaceableResourceInterface_Expecter) ApplyStatus(ctx interface{}, name interface{}, obj interface{}, options interface{}) *MockNamespaceableResourceInterface_ApplyStatus_Call

ApplyStatus is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • obj *unstructured.Unstructured
  • options v1.ApplyOptions

func (*MockNamespaceableResourceInterface_Expecter) Create 

func (_e *MockNamespaceableResourceInterface_Expecter) Create(ctx interface{}, obj interface{}, options interface{}, subresources ...interface{}) *MockNamespaceableResourceInterface_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • obj *unstructured.Unstructured
  • options v1.CreateOptions
  • subresources ...string

func (*MockNamespaceableResourceInterface_Expecter) Delete 

func (_e *MockNamespaceableResourceInterface_Expecter) Delete(ctx interface{}, name interface{}, options interface{}, subresources ...interface{}) *MockNamespaceableResourceInterface_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • options v1.DeleteOptions
  • subresources ...string

func (*MockNamespaceableResourceInterface_Expecter) DeleteCollection 

func (_e *MockNamespaceableResourceInterface_Expecter) DeleteCollection(ctx interface{}, options interface{}, listOptions interface{}) *MockNamespaceableResourceInterface_DeleteCollection_Call

DeleteCollection is a helper method to define mock.On call

  • ctx context.Context
  • options v1.DeleteOptions
  • listOptions v1.ListOptions

func (*MockNamespaceableResourceInterface_Expecter) Get 

func (_e *MockNamespaceableResourceInterface_Expecter) Get(ctx interface{}, name interface{}, options interface{}, subresources ...interface{}) *MockNamespaceableResourceInterface_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • options v1.GetOptions
  • subresources ...string

func (*MockNamespaceableResourceInterface_Expecter) List 

func (_e *MockNamespaceableResourceInterface_Expecter) List(ctx interface{}, opts interface{}) *MockNamespaceableResourceInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context
  • opts v1.ListOptions

func (*MockNamespaceableResourceInterface_Expecter) Namespace 

func (_e *MockNamespaceableResourceInterface_Expecter) Namespace(_a0 interface{}) *MockNamespaceableResourceInterface_Namespace_Call

Namespace is a helper method to define mock.On call

  • _a0 string

func (*MockNamespaceableResourceInterface_Expecter) Patch 

func (_e *MockNamespaceableResourceInterface_Expecter) Patch(ctx interface{}, name interface{}, pt interface{}, data interface{}, options interface{}, subresources ...interface{}) *MockNamespaceableResourceInterface_Patch_Call

Patch is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • pt types.PatchType
  • data []byte
  • options v1.PatchOptions
  • subresources ...string

func (*MockNamespaceableResourceInterface_Expecter) Update 

func (_e *MockNamespaceableResourceInterface_Expecter) Update(ctx interface{}, obj interface{}, options interface{}, subresources ...interface{}) *MockNamespaceableResourceInterface_Update_Call

Update is a helper method to define mock.On call

  • ctx context.Context
  • obj *unstructured.Unstructured
  • options v1.UpdateOptions
  • subresources ...string

func (*MockNamespaceableResourceInterface_Expecter) UpdateStatus 

func (_e *MockNamespaceableResourceInterface_Expecter) UpdateStatus(ctx interface{}, obj interface{}, options interface{}) *MockNamespaceableResourceInterface_UpdateStatus_Call

UpdateStatus is a helper method to define mock.On call

  • ctx context.Context
  • obj *unstructured.Unstructured
  • options v1.UpdateOptions

func (*MockNamespaceableResourceInterface_Expecter) Watch 

func (_e *MockNamespaceableResourceInterface_Expecter) Watch(ctx interface{}, opts interface{}) *MockNamespaceableResourceInterface_Watch_Call

Watch is a helper method to define mock.On call

  • ctx context.Context
  • opts v1.ListOptions

type MockNamespaceableResourceInterface_Get_Call 

type MockNamespaceableResourceInterface_Get_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_Get_Call) Return 

func (_c *MockNamespaceableResourceInterface_Get_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockNamespaceableResourceInterface_Get_Call

func (*MockNamespaceableResourceInterface_Get_Call) Run 

func (_c *MockNamespaceableResourceInterface_Get_Call) Run(run func(ctx context.Context, name string, options v1.GetOptions, subresources ...string)) *MockNamespaceableResourceInterface_Get_Call

func (*MockNamespaceableResourceInterface_Get_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_Get_Call) RunAndReturn(run func(context.Context, string, v1.GetOptions, ...string) (*unstructured.Unstructured, error)) *MockNamespaceableResourceInterface_Get_Call

type MockNamespaceableResourceInterface_List_Call 

type MockNamespaceableResourceInterface_List_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_List_Call) Return 

func (_c *MockNamespaceableResourceInterface_List_Call) Return(_a0 *unstructured.UnstructuredList, _a1 error) *MockNamespaceableResourceInterface_List_Call

func (*MockNamespaceableResourceInterface_List_Call) Run 

func (_c *MockNamespaceableResourceInterface_List_Call) Run(run func(ctx context.Context, opts v1.ListOptions)) *MockNamespaceableResourceInterface_List_Call

func (*MockNamespaceableResourceInterface_List_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_List_Call) RunAndReturn(run func(context.Context, v1.ListOptions) (*unstructured.UnstructuredList, error)) *MockNamespaceableResourceInterface_List_Call

type MockNamespaceableResourceInterface_Namespace_Call 

type MockNamespaceableResourceInterface_Namespace_Call struct {
	*mock.Call
}

MockNamespaceableResourceInterface_Namespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Namespace'

func (*MockNamespaceableResourceInterface_Namespace_Call) Maybe 

func (_c *MockNamespaceableResourceInterface_Namespace_Call) Maybe() *MockNamespaceableResourceInterface_Namespace_Call

This extra code augments the code generated by mockery. Maybe allows a mocked method call to be optional. It is needed for fuzz testing.

func (*MockNamespaceableResourceInterface_Namespace_Call) Return 

func (_c *MockNamespaceableResourceInterface_Namespace_Call) Return(_a0 dynamic.ResourceInterface) *MockNamespaceableResourceInterface_Namespace_Call

func (*MockNamespaceableResourceInterface_Namespace_Call) Run 

func (_c *MockNamespaceableResourceInterface_Namespace_Call) Run(run func(_a0 string)) *MockNamespaceableResourceInterface_Namespace_Call

func (*MockNamespaceableResourceInterface_Namespace_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_Namespace_Call) RunAndReturn(run func(string) dynamic.ResourceInterface) *MockNamespaceableResourceInterface_Namespace_Call

type MockNamespaceableResourceInterface_Patch_Call 

type MockNamespaceableResourceInterface_Patch_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_Patch_Call) Return 

func (_c *MockNamespaceableResourceInterface_Patch_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockNamespaceableResourceInterface_Patch_Call

func (*MockNamespaceableResourceInterface_Patch_Call) Run 

func (_c *MockNamespaceableResourceInterface_Patch_Call) Run(run func(ctx context.Context, name string, pt types.PatchType, data []byte, options v1.PatchOptions, subresources ...string)) *MockNamespaceableResourceInterface_Patch_Call

func (*MockNamespaceableResourceInterface_Patch_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_Patch_Call) RunAndReturn(run func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) (*unstructured.Unstructured, error)) *MockNamespaceableResourceInterface_Patch_Call

type MockNamespaceableResourceInterface_UpdateStatus_Call 

type MockNamespaceableResourceInterface_UpdateStatus_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_UpdateStatus_Call) Return 

func (_c *MockNamespaceableResourceInterface_UpdateStatus_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockNamespaceableResourceInterface_UpdateStatus_Call

func (*MockNamespaceableResourceInterface_UpdateStatus_Call) Run 

func (_c *MockNamespaceableResourceInterface_UpdateStatus_Call) Run(run func(ctx context.Context, obj *unstructured.Unstructured, options v1.UpdateOptions)) *MockNamespaceableResourceInterface_UpdateStatus_Call

func (*MockNamespaceableResourceInterface_UpdateStatus_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_UpdateStatus_Call) RunAndReturn(run func(context.Context, *unstructured.Unstructured, v1.UpdateOptions) (*unstructured.Unstructured, error)) *MockNamespaceableResourceInterface_UpdateStatus_Call

type MockNamespaceableResourceInterface_Update_Call 

type MockNamespaceableResourceInterface_Update_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_Update_Call) Return 

func (_c *MockNamespaceableResourceInterface_Update_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockNamespaceableResourceInterface_Update_Call

func (*MockNamespaceableResourceInterface_Update_Call) Run 

func (_c *MockNamespaceableResourceInterface_Update_Call) Run(run func(ctx context.Context, obj *unstructured.Unstructured, options v1.UpdateOptions, subresources ...string)) *MockNamespaceableResourceInterface_Update_Call

func (*MockNamespaceableResourceInterface_Update_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_Update_Call) RunAndReturn(run func(context.Context, *unstructured.Unstructured, v1.UpdateOptions, ...string) (*unstructured.Unstructured, error)) *MockNamespaceableResourceInterface_Update_Call

type MockNamespaceableResourceInterface_Watch_Call 

type MockNamespaceableResourceInterface_Watch_Call struct {
	*mock.Call
}

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

func (*MockNamespaceableResourceInterface_Watch_Call) Return 

func (_c *MockNamespaceableResourceInterface_Watch_Call) Return(_a0 watch.Interface, _a1 error) *MockNamespaceableResourceInterface_Watch_Call

func (*MockNamespaceableResourceInterface_Watch_Call) Run 

func (_c *MockNamespaceableResourceInterface_Watch_Call) Run(run func(ctx context.Context, opts v1.ListOptions)) *MockNamespaceableResourceInterface_Watch_Call

func (*MockNamespaceableResourceInterface_Watch_Call) RunAndReturn 

func (_c *MockNamespaceableResourceInterface_Watch_Call) RunAndReturn(run func(context.Context, v1.ListOptions) (watch.Interface, error)) *MockNamespaceableResourceInterface_Watch_Call

type MockResourceInterface 

type MockResourceInterface struct {
	mock.Mock
}

MockResourceInterface is an autogenerated mock type for the ResourceInterface type

func NewMockResourceInterface 

func NewMockResourceInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockResourceInterface

NewMockResourceInterface creates a new instance of MockResourceInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockResourceInterface) Apply 

func (_m *MockResourceInterface) Apply(ctx context.Context, name string, obj *unstructured.Unstructured, options v1.ApplyOptions, subresources ...string) (*unstructured.Unstructured, error)

Apply provides a mock function with given fields: ctx, name, obj, options, subresources

func (*MockResourceInterface) ApplyStatus 

func (_m *MockResourceInterface) ApplyStatus(ctx context.Context, name string, obj *unstructured.Unstructured, options v1.ApplyOptions) (*unstructured.Unstructured, error)

ApplyStatus provides a mock function with given fields: ctx, name, obj, options

func (*MockResourceInterface) Create 

func (_m *MockResourceInterface) Create(ctx context.Context, obj *unstructured.Unstructured, options v1.CreateOptions, subresources ...string) (*unstructured.Unstructured, error)

Create provides a mock function with given fields: ctx, obj, options, subresources

func (*MockResourceInterface) Delete 

func (_m *MockResourceInterface) Delete(ctx context.Context, name string, options v1.DeleteOptions, subresources ...string) error

Delete provides a mock function with given fields: ctx, name, options, subresources

func (*MockResourceInterface) DeleteCollection 

func (_m *MockResourceInterface) DeleteCollection(ctx context.Context, options v1.DeleteOptions, listOptions v1.ListOptions) error

DeleteCollection provides a mock function with given fields: ctx, options, listOptions

func (*MockResourceInterface) EXPECT 

func (_m *MockResourceInterface) EXPECT() *MockResourceInterface_Expecter

func (*MockResourceInterface) Get 

func (_m *MockResourceInterface) Get(ctx context.Context, name string, options v1.GetOptions, subresources ...string) (*unstructured.Unstructured, error)

Get provides a mock function with given fields: ctx, name, options, subresources

func (*MockResourceInterface) List 

func (_m *MockResourceInterface) List(ctx context.Context, opts v1.ListOptions) (*unstructured.UnstructuredList, error)

List provides a mock function with given fields: ctx, opts

func (*MockResourceInterface) Patch 

func (_m *MockResourceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, options v1.PatchOptions, subresources ...string) (*unstructured.Unstructured, error)

Patch provides a mock function with given fields: ctx, name, pt, data, options, subresources

func (*MockResourceInterface) Update 

func (_m *MockResourceInterface) Update(ctx context.Context, obj *unstructured.Unstructured, options v1.UpdateOptions, subresources ...string) (*unstructured.Unstructured, error)

Update provides a mock function with given fields: ctx, obj, options, subresources

func (*MockResourceInterface) UpdateStatus 

func (_m *MockResourceInterface) UpdateStatus(ctx context.Context, obj *unstructured.Unstructured, options v1.UpdateOptions) (*unstructured.Unstructured, error)

UpdateStatus provides a mock function with given fields: ctx, obj, options

func (*MockResourceInterface) Watch 

func (_m *MockResourceInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)

Watch provides a mock function with given fields: ctx, opts

type MockResourceInterface_ApplyStatus_Call 

type MockResourceInterface_ApplyStatus_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_ApplyStatus_Call) Return 

func (_c *MockResourceInterface_ApplyStatus_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockResourceInterface_ApplyStatus_Call

func (*MockResourceInterface_ApplyStatus_Call) Run 

func (_c *MockResourceInterface_ApplyStatus_Call) Run(run func(ctx context.Context, name string, obj *unstructured.Unstructured, options v1.ApplyOptions)) *MockResourceInterface_ApplyStatus_Call

func (*MockResourceInterface_ApplyStatus_Call) RunAndReturn 

func (_c *MockResourceInterface_ApplyStatus_Call) RunAndReturn(run func(context.Context, string, *unstructured.Unstructured, v1.ApplyOptions) (*unstructured.Unstructured, error)) *MockResourceInterface_ApplyStatus_Call

type MockResourceInterface_Apply_Call 

type MockResourceInterface_Apply_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_Apply_Call) Return 

func (_c *MockResourceInterface_Apply_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockResourceInterface_Apply_Call

func (*MockResourceInterface_Apply_Call) Run 

func (_c *MockResourceInterface_Apply_Call) Run(run func(ctx context.Context, name string, obj *unstructured.Unstructured, options v1.ApplyOptions, subresources ...string)) *MockResourceInterface_Apply_Call

func (*MockResourceInterface_Apply_Call) RunAndReturn 

func (_c *MockResourceInterface_Apply_Call) RunAndReturn(run func(context.Context, string, *unstructured.Unstructured, v1.ApplyOptions, ...string) (*unstructured.Unstructured, error)) *MockResourceInterface_Apply_Call

type MockResourceInterface_Create_Call 

type MockResourceInterface_Create_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_Create_Call) Return 

func (_c *MockResourceInterface_Create_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockResourceInterface_Create_Call

func (*MockResourceInterface_Create_Call) Run 

func (_c *MockResourceInterface_Create_Call) Run(run func(ctx context.Context, obj *unstructured.Unstructured, options v1.CreateOptions, subresources ...string)) *MockResourceInterface_Create_Call

func (*MockResourceInterface_Create_Call) RunAndReturn 

func (_c *MockResourceInterface_Create_Call) RunAndReturn(run func(context.Context, *unstructured.Unstructured, v1.CreateOptions, ...string) (*unstructured.Unstructured, error)) *MockResourceInterface_Create_Call

type MockResourceInterface_DeleteCollection_Call 

type MockResourceInterface_DeleteCollection_Call struct {
	*mock.Call
}

MockResourceInterface_DeleteCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCollection'

func (*MockResourceInterface_DeleteCollection_Call) Return 

func (_c *MockResourceInterface_DeleteCollection_Call) Return(_a0 error) *MockResourceInterface_DeleteCollection_Call

func (*MockResourceInterface_DeleteCollection_Call) Run 

func (_c *MockResourceInterface_DeleteCollection_Call) Run(run func(ctx context.Context, options v1.DeleteOptions, listOptions v1.ListOptions)) *MockResourceInterface_DeleteCollection_Call

func (*MockResourceInterface_DeleteCollection_Call) RunAndReturn 

func (_c *MockResourceInterface_DeleteCollection_Call) RunAndReturn(run func(context.Context, v1.DeleteOptions, v1.ListOptions) error) *MockResourceInterface_DeleteCollection_Call

type MockResourceInterface_Delete_Call 

type MockResourceInterface_Delete_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_Delete_Call) Return 

func (_c *MockResourceInterface_Delete_Call) Return(_a0 error) *MockResourceInterface_Delete_Call

func (*MockResourceInterface_Delete_Call) Run 

func (_c *MockResourceInterface_Delete_Call) Run(run func(ctx context.Context, name string, options v1.DeleteOptions, subresources ...string)) *MockResourceInterface_Delete_Call

func (*MockResourceInterface_Delete_Call) RunAndReturn 

func (_c *MockResourceInterface_Delete_Call) RunAndReturn(run func(context.Context, string, v1.DeleteOptions, ...string) error) *MockResourceInterface_Delete_Call

type MockResourceInterface_Expecter 

type MockResourceInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockResourceInterface_Expecter) Apply 

func (_e *MockResourceInterface_Expecter) Apply(ctx interface{}, name interface{}, obj interface{}, options interface{}, subresources ...interface{}) *MockResourceInterface_Apply_Call

Apply is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • obj *unstructured.Unstructured
  • options v1.ApplyOptions
  • subresources ...string

func (*MockResourceInterface_Expecter) ApplyStatus 

func (_e *MockResourceInterface_Expecter) ApplyStatus(ctx interface{}, name interface{}, obj interface{}, options interface{}) *MockResourceInterface_ApplyStatus_Call

ApplyStatus is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • obj *unstructured.Unstructured
  • options v1.ApplyOptions

func (*MockResourceInterface_Expecter) Create 

func (_e *MockResourceInterface_Expecter) Create(ctx interface{}, obj interface{}, options interface{}, subresources ...interface{}) *MockResourceInterface_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • obj *unstructured.Unstructured
  • options v1.CreateOptions
  • subresources ...string

func (*MockResourceInterface_Expecter) Delete 

func (_e *MockResourceInterface_Expecter) Delete(ctx interface{}, name interface{}, options interface{}, subresources ...interface{}) *MockResourceInterface_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • options v1.DeleteOptions
  • subresources ...string

func (*MockResourceInterface_Expecter) DeleteCollection 

func (_e *MockResourceInterface_Expecter) DeleteCollection(ctx interface{}, options interface{}, listOptions interface{}) *MockResourceInterface_DeleteCollection_Call

DeleteCollection is a helper method to define mock.On call

  • ctx context.Context
  • options v1.DeleteOptions
  • listOptions v1.ListOptions

func (*MockResourceInterface_Expecter) Get 

func (_e *MockResourceInterface_Expecter) Get(ctx interface{}, name interface{}, options interface{}, subresources ...interface{}) *MockResourceInterface_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • options v1.GetOptions
  • subresources ...string

func (*MockResourceInterface_Expecter) List 

func (_e *MockResourceInterface_Expecter) List(ctx interface{}, opts interface{}) *MockResourceInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context
  • opts v1.ListOptions

func (*MockResourceInterface_Expecter) Patch 

func (_e *MockResourceInterface_Expecter) Patch(ctx interface{}, name interface{}, pt interface{}, data interface{}, options interface{}, subresources ...interface{}) *MockResourceInterface_Patch_Call

Patch is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • pt types.PatchType
  • data []byte
  • options v1.PatchOptions
  • subresources ...string

func (*MockResourceInterface_Expecter) Update 

func (_e *MockResourceInterface_Expecter) Update(ctx interface{}, obj interface{}, options interface{}, subresources ...interface{}) *MockResourceInterface_Update_Call

Update is a helper method to define mock.On call

  • ctx context.Context
  • obj *unstructured.Unstructured
  • options v1.UpdateOptions
  • subresources ...string

func (*MockResourceInterface_Expecter) UpdateStatus 

func (_e *MockResourceInterface_Expecter) UpdateStatus(ctx interface{}, obj interface{}, options interface{}) *MockResourceInterface_UpdateStatus_Call

UpdateStatus is a helper method to define mock.On call

  • ctx context.Context
  • obj *unstructured.Unstructured
  • options v1.UpdateOptions

func (*MockResourceInterface_Expecter) Watch 

func (_e *MockResourceInterface_Expecter) Watch(ctx interface{}, opts interface{}) *MockResourceInterface_Watch_Call

Watch is a helper method to define mock.On call

  • ctx context.Context
  • opts v1.ListOptions

type MockResourceInterface_Get_Call 

type MockResourceInterface_Get_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_Get_Call) Return 

func (_c *MockResourceInterface_Get_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockResourceInterface_Get_Call

func (*MockResourceInterface_Get_Call) Run 

func (_c *MockResourceInterface_Get_Call) Run(run func(ctx context.Context, name string, options v1.GetOptions, subresources ...string)) *MockResourceInterface_Get_Call

func (*MockResourceInterface_Get_Call) RunAndReturn 

func (_c *MockResourceInterface_Get_Call) RunAndReturn(run func(context.Context, string, v1.GetOptions, ...string) (*unstructured.Unstructured, error)) *MockResourceInterface_Get_Call

type MockResourceInterface_List_Call 

type MockResourceInterface_List_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_List_Call) Maybe 

func (_c *MockResourceInterface_List_Call) Maybe() *MockResourceInterface_List_Call

This extra code augments the code generated by mockery. Maybe allows a mocked method call to be optional. It is needed for fuzz testing.

func (*MockResourceInterface_List_Call) Return 

func (_c *MockResourceInterface_List_Call) Return(_a0 *unstructured.UnstructuredList, _a1 error) *MockResourceInterface_List_Call

func (*MockResourceInterface_List_Call) Run 

func (_c *MockResourceInterface_List_Call) Run(run func(ctx context.Context, opts v1.ListOptions)) *MockResourceInterface_List_Call

func (*MockResourceInterface_List_Call) RunAndReturn 

func (_c *MockResourceInterface_List_Call) RunAndReturn(run func(context.Context, v1.ListOptions) (*unstructured.UnstructuredList, error)) *MockResourceInterface_List_Call

type MockResourceInterface_Patch_Call 

type MockResourceInterface_Patch_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_Patch_Call) Return 

func (_c *MockResourceInterface_Patch_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockResourceInterface_Patch_Call

func (*MockResourceInterface_Patch_Call) Run 

func (_c *MockResourceInterface_Patch_Call) Run(run func(ctx context.Context, name string, pt types.PatchType, data []byte, options v1.PatchOptions, subresources ...string)) *MockResourceInterface_Patch_Call

func (*MockResourceInterface_Patch_Call) RunAndReturn 

func (_c *MockResourceInterface_Patch_Call) RunAndReturn(run func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) (*unstructured.Unstructured, error)) *MockResourceInterface_Patch_Call

type MockResourceInterface_UpdateStatus_Call 

type MockResourceInterface_UpdateStatus_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_UpdateStatus_Call) Return 

func (_c *MockResourceInterface_UpdateStatus_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockResourceInterface_UpdateStatus_Call

func (*MockResourceInterface_UpdateStatus_Call) Run 

func (_c *MockResourceInterface_UpdateStatus_Call) Run(run func(ctx context.Context, obj *unstructured.Unstructured, options v1.UpdateOptions)) *MockResourceInterface_UpdateStatus_Call

func (*MockResourceInterface_UpdateStatus_Call) RunAndReturn 

func (_c *MockResourceInterface_UpdateStatus_Call) RunAndReturn(run func(context.Context, *unstructured.Unstructured, v1.UpdateOptions) (*unstructured.Unstructured, error)) *MockResourceInterface_UpdateStatus_Call

type MockResourceInterface_Update_Call 

type MockResourceInterface_Update_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_Update_Call) Return 

func (_c *MockResourceInterface_Update_Call) Return(_a0 *unstructured.Unstructured, _a1 error) *MockResourceInterface_Update_Call

func (*MockResourceInterface_Update_Call) Run 

func (_c *MockResourceInterface_Update_Call) Run(run func(ctx context.Context, obj *unstructured.Unstructured, options v1.UpdateOptions, subresources ...string)) *MockResourceInterface_Update_Call

func (*MockResourceInterface_Update_Call) RunAndReturn 

func (_c *MockResourceInterface_Update_Call) RunAndReturn(run func(context.Context, *unstructured.Unstructured, v1.UpdateOptions, ...string) (*unstructured.Unstructured, error)) *MockResourceInterface_Update_Call

type MockResourceInterface_Watch_Call 

type MockResourceInterface_Watch_Call struct {
	*mock.Call
}

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

func (*MockResourceInterface_Watch_Call) Return 

func (_c *MockResourceInterface_Watch_Call) Return(_a0 watch.Interface, _a1 error) *MockResourceInterface_Watch_Call

func (*MockResourceInterface_Watch_Call) Run 

func (_c *MockResourceInterface_Watch_Call) Run(run func(ctx context.Context, opts v1.ListOptions)) *MockResourceInterface_Watch_Call

func (*MockResourceInterface_Watch_Call) RunAndReturn 

func (_c *MockResourceInterface_Watch_Call) RunAndReturn(run func(context.Context, v1.ListOptions) (watch.Interface, error)) *MockResourceInterface_Watch_Call

type MockTenantAwareInventoryClient 

type MockTenantAwareInventoryClient struct {
	mock.Mock
}

MockTenantAwareInventoryClient is an autogenerated mock type for the TenantAwareInventoryClient type

func NewMockTenantAwareInventoryClient 

func NewMockTenantAwareInventoryClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTenantAwareInventoryClient

NewMockTenantAwareInventoryClient creates a new instance of MockTenantAwareInventoryClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockTenantAwareInventoryClient) Close 

func (_m *MockTenantAwareInventoryClient) Close() error

Close provides a mock function with no fields

func (*MockTenantAwareInventoryClient) Create 

func (_m *MockTenantAwareInventoryClient) Create(ctx context.Context, tenantID string, res *inventoryv1.Resource) (*inventoryv1.Resource, error)

Create provides a mock function with given fields: ctx, tenantID, res

func (*MockTenantAwareInventoryClient) Delete 

func (_m *MockTenantAwareInventoryClient) Delete(ctx context.Context, tenantID string, id string) (*inventoryv1.DeleteResourceResponse, error)

Delete provides a mock function with given fields: ctx, tenantID, id

func (*MockTenantAwareInventoryClient) DeleteAllResources 

func (_m *MockTenantAwareInventoryClient) DeleteAllResources(ctx context.Context, tenantID string, kind inventoryv1.ResourceKind, enforce bool) error

DeleteAllResources provides a mock function with given fields: ctx, tenantID, kind, enforce

func (*MockTenantAwareInventoryClient) EXPECT 

func (_m *MockTenantAwareInventoryClient) EXPECT() *MockTenantAwareInventoryClient_Expecter

func (*MockTenantAwareInventoryClient) Find 

func (_m *MockTenantAwareInventoryClient) Find(_a0 context.Context, _a1 *inventoryv1.ResourceFilter) (*inventoryv1.FindResourcesResponse, error)

Find provides a mock function with given fields: _a0, _a1

func (*MockTenantAwareInventoryClient) FindAll 

func (_m *MockTenantAwareInventoryClient) FindAll(_a0 context.Context, _a1 *inventoryv1.ResourceFilter) ([]*inventoryv1.FindResourcesResponse_ResourceTenantIDCarrier, error)

FindAll provides a mock function with given fields: _a0, _a1

func (*MockTenantAwareInventoryClient) Get 

func (_m *MockTenantAwareInventoryClient) Get(ctx context.Context, tenantID string, id string) (*inventoryv1.GetResourceResponse, error)

Get provides a mock function with given fields: ctx, tenantID, id

func (*MockTenantAwareInventoryClient) GetHostByUUID 

func (_m *MockTenantAwareInventoryClient) GetHostByUUID(ctx context.Context, tenantID string, uuid string) (*computev1.HostResource, error)

GetHostByUUID provides a mock function with given fields: ctx, tenantID, uuid

func (*MockTenantAwareInventoryClient) GetSitesPerRegion 

func (_m *MockTenantAwareInventoryClient) GetSitesPerRegion(_a0 context.Context, _a1 *inventoryv1.GetSitesPerRegionRequest) (*inventoryv1.GetSitesPerRegionResponse, error)

GetSitesPerRegion provides a mock function with given fields: _a0, _a1

func (*MockTenantAwareInventoryClient) GetTreeHierarchy 

func (_m *MockTenantAwareInventoryClient) GetTreeHierarchy(_a0 context.Context, _a1 *inventoryv1.GetTreeHierarchyRequest) ([]*inventoryv1.GetTreeHierarchyResponse_TreeNode, error)

GetTreeHierarchy provides a mock function with given fields: _a0, _a1

func (*MockTenantAwareInventoryClient) List 

func (_m *MockTenantAwareInventoryClient) List(_a0 context.Context, _a1 *inventoryv1.ResourceFilter) (*inventoryv1.ListResourcesResponse, error)

List provides a mock function with given fields: _a0, _a1

func (*MockTenantAwareInventoryClient) ListAll 

func (_m *MockTenantAwareInventoryClient) ListAll(_a0 context.Context, _a1 *inventoryv1.ResourceFilter) ([]*inventoryv1.Resource, error)

ListAll provides a mock function with given fields: _a0, _a1

func (*MockTenantAwareInventoryClient) ListInheritedTelemetryProfiles 

func (_m *MockTenantAwareInventoryClient) ListInheritedTelemetryProfiles(ctx context.Context, tenantID string, inheritBy *inventoryv1.ListInheritedTelemetryProfilesRequest_InheritBy, filter string, orderBy string, limit uint32, offset uint32) (*inventoryv1.ListInheritedTelemetryProfilesResponse, error)

ListInheritedTelemetryProfiles provides a mock function with given fields: ctx, tenantID, inheritBy, filter, orderBy, limit, offset

func (*MockTenantAwareInventoryClient) TestGetClientCache 

func (_m *MockTenantAwareInventoryClient) TestGetClientCache() *cache.InventoryCache

TestGetClientCache provides a mock function with no fields

func (*MockTenantAwareInventoryClient) TestGetClientCacheUUID 

func (_m *MockTenantAwareInventoryClient) TestGetClientCacheUUID() *cache.InventoryCache

TestGetClientCacheUUID provides a mock function with no fields

func (*MockTenantAwareInventoryClient) TestingOnlySetClient 

func (_m *MockTenantAwareInventoryClient) TestingOnlySetClient(_a0 inventoryv1.InventoryServiceClient)

TestingOnlySetClient provides a mock function with given fields: _a0

func (*MockTenantAwareInventoryClient) Update 

func (_m *MockTenantAwareInventoryClient) Update(ctx context.Context, tenantID string, id string, fm *fieldmaskpb.FieldMask, res *inventoryv1.Resource) (*inventoryv1.Resource, error)

Update provides a mock function with given fields: ctx, tenantID, id, fm, res

func (*MockTenantAwareInventoryClient) UpdateSubscriptions 

func (_m *MockTenantAwareInventoryClient) UpdateSubscriptions(ctx context.Context, tenantID string, kinds []inventoryv1.ResourceKind) error

UpdateSubscriptions provides a mock function with given fields: ctx, tenantID, kinds

type MockTenantAwareInventoryClient_Close_Call 

type MockTenantAwareInventoryClient_Close_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'

func (*MockTenantAwareInventoryClient_Close_Call) Return 

func (_c *MockTenantAwareInventoryClient_Close_Call) Return(_a0 error) *MockTenantAwareInventoryClient_Close_Call

func (*MockTenantAwareInventoryClient_Close_Call) Run 

func (_c *MockTenantAwareInventoryClient_Close_Call) Run(run func()) *MockTenantAwareInventoryClient_Close_Call

func (*MockTenantAwareInventoryClient_Close_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_Close_Call) RunAndReturn(run func() error) *MockTenantAwareInventoryClient_Close_Call

type MockTenantAwareInventoryClient_Create_Call 

type MockTenantAwareInventoryClient_Create_Call struct {
	*mock.Call
}

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

func (*MockTenantAwareInventoryClient_Create_Call) Return 

func (_c *MockTenantAwareInventoryClient_Create_Call) Return(_a0 *inventoryv1.Resource, _a1 error) *MockTenantAwareInventoryClient_Create_Call

func (*MockTenantAwareInventoryClient_Create_Call) Run 

func (_c *MockTenantAwareInventoryClient_Create_Call) Run(run func(ctx context.Context, tenantID string, res *inventoryv1.Resource)) *MockTenantAwareInventoryClient_Create_Call

func (*MockTenantAwareInventoryClient_Create_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_Create_Call) RunAndReturn(run func(context.Context, string, *inventoryv1.Resource) (*inventoryv1.Resource, error)) *MockTenantAwareInventoryClient_Create_Call

type MockTenantAwareInventoryClient_DeleteAllResources_Call 

type MockTenantAwareInventoryClient_DeleteAllResources_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_DeleteAllResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllResources'

func (*MockTenantAwareInventoryClient_DeleteAllResources_Call) Return 

func (_c *MockTenantAwareInventoryClient_DeleteAllResources_Call) Return(_a0 error) *MockTenantAwareInventoryClient_DeleteAllResources_Call

func (*MockTenantAwareInventoryClient_DeleteAllResources_Call) Run 

func (_c *MockTenantAwareInventoryClient_DeleteAllResources_Call) Run(run func(ctx context.Context, tenantID string, kind inventoryv1.ResourceKind, enforce bool)) *MockTenantAwareInventoryClient_DeleteAllResources_Call

func (*MockTenantAwareInventoryClient_DeleteAllResources_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_DeleteAllResources_Call) RunAndReturn(run func(context.Context, string, inventoryv1.ResourceKind, bool) error) *MockTenantAwareInventoryClient_DeleteAllResources_Call

type MockTenantAwareInventoryClient_Delete_Call 

type MockTenantAwareInventoryClient_Delete_Call struct {
	*mock.Call
}

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

func (*MockTenantAwareInventoryClient_Delete_Call) Return 

func (_c *MockTenantAwareInventoryClient_Delete_Call) Return(_a0 *inventoryv1.DeleteResourceResponse, _a1 error) *MockTenantAwareInventoryClient_Delete_Call

func (*MockTenantAwareInventoryClient_Delete_Call) Run 

func (_c *MockTenantAwareInventoryClient_Delete_Call) Run(run func(ctx context.Context, tenantID string, id string)) *MockTenantAwareInventoryClient_Delete_Call

func (*MockTenantAwareInventoryClient_Delete_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_Delete_Call) RunAndReturn(run func(context.Context, string, string) (*inventoryv1.DeleteResourceResponse, error)) *MockTenantAwareInventoryClient_Delete_Call

type MockTenantAwareInventoryClient_Expecter 

type MockTenantAwareInventoryClient_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockTenantAwareInventoryClient_Expecter) Close 

func (_e *MockTenantAwareInventoryClient_Expecter) Close() *MockTenantAwareInventoryClient_Close_Call

Close is a helper method to define mock.On call

func (*MockTenantAwareInventoryClient_Expecter) Create 

func (_e *MockTenantAwareInventoryClient_Expecter) Create(ctx interface{}, tenantID interface{}, res interface{}) *MockTenantAwareInventoryClient_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • tenantID string
  • res *inventoryv1.Resource

func (*MockTenantAwareInventoryClient_Expecter) Delete 

func (_e *MockTenantAwareInventoryClient_Expecter) Delete(ctx interface{}, tenantID interface{}, id interface{}) *MockTenantAwareInventoryClient_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • tenantID string
  • id string

func (*MockTenantAwareInventoryClient_Expecter) DeleteAllResources 

func (_e *MockTenantAwareInventoryClient_Expecter) DeleteAllResources(ctx interface{}, tenantID interface{}, kind interface{}, enforce interface{}) *MockTenantAwareInventoryClient_DeleteAllResources_Call

DeleteAllResources is a helper method to define mock.On call

  • ctx context.Context
  • tenantID string
  • kind inventoryv1.ResourceKind
  • enforce bool

func (*MockTenantAwareInventoryClient_Expecter) Find 

func (_e *MockTenantAwareInventoryClient_Expecter) Find(_a0 interface{}, _a1 interface{}) *MockTenantAwareInventoryClient_Find_Call

Find is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *inventoryv1.ResourceFilter

func (*MockTenantAwareInventoryClient_Expecter) FindAll 

func (_e *MockTenantAwareInventoryClient_Expecter) FindAll(_a0 interface{}, _a1 interface{}) *MockTenantAwareInventoryClient_FindAll_Call

FindAll is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *inventoryv1.ResourceFilter

func (*MockTenantAwareInventoryClient_Expecter) Get 

func (_e *MockTenantAwareInventoryClient_Expecter) Get(ctx interface{}, tenantID interface{}, id interface{}) *MockTenantAwareInventoryClient_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • tenantID string
  • id string

func (*MockTenantAwareInventoryClient_Expecter) GetHostByUUID 

func (_e *MockTenantAwareInventoryClient_Expecter) GetHostByUUID(ctx interface{}, tenantID interface{}, uuid interface{}) *MockTenantAwareInventoryClient_GetHostByUUID_Call

GetHostByUUID is a helper method to define mock.On call

  • ctx context.Context
  • tenantID string
  • uuid string

func (*MockTenantAwareInventoryClient_Expecter) GetSitesPerRegion 

func (_e *MockTenantAwareInventoryClient_Expecter) GetSitesPerRegion(_a0 interface{}, _a1 interface{}) *MockTenantAwareInventoryClient_GetSitesPerRegion_Call

GetSitesPerRegion is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *inventoryv1.GetSitesPerRegionRequest

func (*MockTenantAwareInventoryClient_Expecter) GetTreeHierarchy 

func (_e *MockTenantAwareInventoryClient_Expecter) GetTreeHierarchy(_a0 interface{}, _a1 interface{}) *MockTenantAwareInventoryClient_GetTreeHierarchy_Call

GetTreeHierarchy is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *inventoryv1.GetTreeHierarchyRequest

func (*MockTenantAwareInventoryClient_Expecter) List 

func (_e *MockTenantAwareInventoryClient_Expecter) List(_a0 interface{}, _a1 interface{}) *MockTenantAwareInventoryClient_List_Call

List is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *inventoryv1.ResourceFilter

func (*MockTenantAwareInventoryClient_Expecter) ListAll 

func (_e *MockTenantAwareInventoryClient_Expecter) ListAll(_a0 interface{}, _a1 interface{}) *MockTenantAwareInventoryClient_ListAll_Call

ListAll is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *inventoryv1.ResourceFilter

func (*MockTenantAwareInventoryClient_Expecter) ListInheritedTelemetryProfiles 

func (_e *MockTenantAwareInventoryClient_Expecter) ListInheritedTelemetryProfiles(ctx interface{}, tenantID interface{}, inheritBy interface{}, filter interface{}, orderBy interface{}, limit interface{}, offset interface{}) *MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call

ListInheritedTelemetryProfiles is a helper method to define mock.On call

  • ctx context.Context
  • tenantID string
  • inheritBy *inventoryv1.ListInheritedTelemetryProfilesRequest_InheritBy
  • filter string
  • orderBy string
  • limit uint32
  • offset uint32

func (*MockTenantAwareInventoryClient_Expecter) TestGetClientCache 

func (_e *MockTenantAwareInventoryClient_Expecter) TestGetClientCache() *MockTenantAwareInventoryClient_TestGetClientCache_Call

TestGetClientCache is a helper method to define mock.On call

func (*MockTenantAwareInventoryClient_Expecter) TestGetClientCacheUUID 

func (_e *MockTenantAwareInventoryClient_Expecter) TestGetClientCacheUUID() *MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call

TestGetClientCacheUUID is a helper method to define mock.On call

func (*MockTenantAwareInventoryClient_Expecter) TestingOnlySetClient 

func (_e *MockTenantAwareInventoryClient_Expecter) TestingOnlySetClient(_a0 interface{}) *MockTenantAwareInventoryClient_TestingOnlySetClient_Call

TestingOnlySetClient is a helper method to define mock.On call

  • _a0 inventoryv1.InventoryServiceClient

func (*MockTenantAwareInventoryClient_Expecter) Update 

func (_e *MockTenantAwareInventoryClient_Expecter) Update(ctx interface{}, tenantID interface{}, id interface{}, fm interface{}, res interface{}) *MockTenantAwareInventoryClient_Update_Call

Update is a helper method to define mock.On call

  • ctx context.Context
  • tenantID string
  • id string
  • fm *fieldmaskpb.FieldMask
  • res *inventoryv1.Resource

func (*MockTenantAwareInventoryClient_Expecter) UpdateSubscriptions 

func (_e *MockTenantAwareInventoryClient_Expecter) UpdateSubscriptions(ctx interface{}, tenantID interface{}, kinds interface{}) *MockTenantAwareInventoryClient_UpdateSubscriptions_Call

UpdateSubscriptions is a helper method to define mock.On call

  • ctx context.Context
  • tenantID string
  • kinds []inventoryv1.ResourceKind

type MockTenantAwareInventoryClient_FindAll_Call 

type MockTenantAwareInventoryClient_FindAll_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_FindAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAll'

func (*MockTenantAwareInventoryClient_FindAll_Call) Return 

func (_c *MockTenantAwareInventoryClient_FindAll_Call) Return(_a0 []*inventoryv1.FindResourcesResponse_ResourceTenantIDCarrier, _a1 error) *MockTenantAwareInventoryClient_FindAll_Call

func (*MockTenantAwareInventoryClient_FindAll_Call) Run 

func (_c *MockTenantAwareInventoryClient_FindAll_Call) Run(run func(_a0 context.Context, _a1 *inventoryv1.ResourceFilter)) *MockTenantAwareInventoryClient_FindAll_Call

func (*MockTenantAwareInventoryClient_FindAll_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_FindAll_Call) RunAndReturn(run func(context.Context, *inventoryv1.ResourceFilter) ([]*inventoryv1.FindResourcesResponse_ResourceTenantIDCarrier, error)) *MockTenantAwareInventoryClient_FindAll_Call

type MockTenantAwareInventoryClient_Find_Call 

type MockTenantAwareInventoryClient_Find_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_Find_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Find'

func (*MockTenantAwareInventoryClient_Find_Call) Return 

func (_c *MockTenantAwareInventoryClient_Find_Call) Return(_a0 *inventoryv1.FindResourcesResponse, _a1 error) *MockTenantAwareInventoryClient_Find_Call

func (*MockTenantAwareInventoryClient_Find_Call) Run 

func (_c *MockTenantAwareInventoryClient_Find_Call) Run(run func(_a0 context.Context, _a1 *inventoryv1.ResourceFilter)) *MockTenantAwareInventoryClient_Find_Call

func (*MockTenantAwareInventoryClient_Find_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_Find_Call) RunAndReturn(run func(context.Context, *inventoryv1.ResourceFilter) (*inventoryv1.FindResourcesResponse, error)) *MockTenantAwareInventoryClient_Find_Call

type MockTenantAwareInventoryClient_GetHostByUUID_Call 

type MockTenantAwareInventoryClient_GetHostByUUID_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_GetHostByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHostByUUID'

func (*MockTenantAwareInventoryClient_GetHostByUUID_Call) Return 

func (_c *MockTenantAwareInventoryClient_GetHostByUUID_Call) Return(_a0 *computev1.HostResource, _a1 error) *MockTenantAwareInventoryClient_GetHostByUUID_Call

func (*MockTenantAwareInventoryClient_GetHostByUUID_Call) Run 

func (_c *MockTenantAwareInventoryClient_GetHostByUUID_Call) Run(run func(ctx context.Context, tenantID string, uuid string)) *MockTenantAwareInventoryClient_GetHostByUUID_Call

func (*MockTenantAwareInventoryClient_GetHostByUUID_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_GetHostByUUID_Call) RunAndReturn(run func(context.Context, string, string) (*computev1.HostResource, error)) *MockTenantAwareInventoryClient_GetHostByUUID_Call

type MockTenantAwareInventoryClient_GetSitesPerRegion_Call 

type MockTenantAwareInventoryClient_GetSitesPerRegion_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_GetSitesPerRegion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSitesPerRegion'

func (*MockTenantAwareInventoryClient_GetSitesPerRegion_Call) Return 

func (_c *MockTenantAwareInventoryClient_GetSitesPerRegion_Call) Return(_a0 *inventoryv1.GetSitesPerRegionResponse, _a1 error) *MockTenantAwareInventoryClient_GetSitesPerRegion_Call

func (*MockTenantAwareInventoryClient_GetSitesPerRegion_Call) Run 

func (_c *MockTenantAwareInventoryClient_GetSitesPerRegion_Call) Run(run func(_a0 context.Context, _a1 *inventoryv1.GetSitesPerRegionRequest)) *MockTenantAwareInventoryClient_GetSitesPerRegion_Call

func (*MockTenantAwareInventoryClient_GetSitesPerRegion_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_GetSitesPerRegion_Call) RunAndReturn(run func(context.Context, *inventoryv1.GetSitesPerRegionRequest) (*inventoryv1.GetSitesPerRegionResponse, error)) *MockTenantAwareInventoryClient_GetSitesPerRegion_Call

type MockTenantAwareInventoryClient_GetTreeHierarchy_Call 

type MockTenantAwareInventoryClient_GetTreeHierarchy_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_GetTreeHierarchy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTreeHierarchy'

func (*MockTenantAwareInventoryClient_GetTreeHierarchy_Call) Return 

func (_c *MockTenantAwareInventoryClient_GetTreeHierarchy_Call) Return(_a0 []*inventoryv1.GetTreeHierarchyResponse_TreeNode, _a1 error) *MockTenantAwareInventoryClient_GetTreeHierarchy_Call

func (*MockTenantAwareInventoryClient_GetTreeHierarchy_Call) Run 

func (_c *MockTenantAwareInventoryClient_GetTreeHierarchy_Call) Run(run func(_a0 context.Context, _a1 *inventoryv1.GetTreeHierarchyRequest)) *MockTenantAwareInventoryClient_GetTreeHierarchy_Call

func (*MockTenantAwareInventoryClient_GetTreeHierarchy_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_GetTreeHierarchy_Call) RunAndReturn(run func(context.Context, *inventoryv1.GetTreeHierarchyRequest) ([]*inventoryv1.GetTreeHierarchyResponse_TreeNode, error)) *MockTenantAwareInventoryClient_GetTreeHierarchy_Call

type MockTenantAwareInventoryClient_Get_Call 

type MockTenantAwareInventoryClient_Get_Call struct {
	*mock.Call
}

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

func (*MockTenantAwareInventoryClient_Get_Call) Return 

func (_c *MockTenantAwareInventoryClient_Get_Call) Return(_a0 *inventoryv1.GetResourceResponse, _a1 error) *MockTenantAwareInventoryClient_Get_Call

func (*MockTenantAwareInventoryClient_Get_Call) Run 

func (_c *MockTenantAwareInventoryClient_Get_Call) Run(run func(ctx context.Context, tenantID string, id string)) *MockTenantAwareInventoryClient_Get_Call

func (*MockTenantAwareInventoryClient_Get_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_Get_Call) RunAndReturn(run func(context.Context, string, string) (*inventoryv1.GetResourceResponse, error)) *MockTenantAwareInventoryClient_Get_Call

type MockTenantAwareInventoryClient_ListAll_Call 

type MockTenantAwareInventoryClient_ListAll_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'

func (*MockTenantAwareInventoryClient_ListAll_Call) Return 

func (_c *MockTenantAwareInventoryClient_ListAll_Call) Return(_a0 []*inventoryv1.Resource, _a1 error) *MockTenantAwareInventoryClient_ListAll_Call

func (*MockTenantAwareInventoryClient_ListAll_Call) Run 

func (_c *MockTenantAwareInventoryClient_ListAll_Call) Run(run func(_a0 context.Context, _a1 *inventoryv1.ResourceFilter)) *MockTenantAwareInventoryClient_ListAll_Call

func (*MockTenantAwareInventoryClient_ListAll_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_ListAll_Call) RunAndReturn(run func(context.Context, *inventoryv1.ResourceFilter) ([]*inventoryv1.Resource, error)) *MockTenantAwareInventoryClient_ListAll_Call

type MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call 

type MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListInheritedTelemetryProfiles'

func (*MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call) Return 

func (_c *MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call) Return(_a0 *inventoryv1.ListInheritedTelemetryProfilesResponse, _a1 error) *MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call

func (*MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call) Run 

func (_c *MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call) Run(run func(ctx context.Context, tenantID string, inheritBy *inventoryv1.ListInheritedTelemetryProfilesRequest_InheritBy, filter string, orderBy string, limit uint32, offset uint32)) *MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call

func (*MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call) RunAndReturn(run func(context.Context, string, *inventoryv1.ListInheritedTelemetryProfilesRequest_InheritBy, string, string, uint32, uint32) (*inventoryv1.ListInheritedTelemetryProfilesResponse, error)) *MockTenantAwareInventoryClient_ListInheritedTelemetryProfiles_Call

type MockTenantAwareInventoryClient_List_Call 

type MockTenantAwareInventoryClient_List_Call struct {
	*mock.Call
}

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

func (*MockTenantAwareInventoryClient_List_Call) Return 

func (_c *MockTenantAwareInventoryClient_List_Call) Return(_a0 *inventoryv1.ListResourcesResponse, _a1 error) *MockTenantAwareInventoryClient_List_Call

func (*MockTenantAwareInventoryClient_List_Call) Run 

func (_c *MockTenantAwareInventoryClient_List_Call) Run(run func(_a0 context.Context, _a1 *inventoryv1.ResourceFilter)) *MockTenantAwareInventoryClient_List_Call

func (*MockTenantAwareInventoryClient_List_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_List_Call) RunAndReturn(run func(context.Context, *inventoryv1.ResourceFilter) (*inventoryv1.ListResourcesResponse, error)) *MockTenantAwareInventoryClient_List_Call

type MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call 

type MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestGetClientCacheUUID'

func (*MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call) Return 

func (_c *MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call) Return(_a0 *cache.InventoryCache) *MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call

func (*MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call) Run 

func (_c *MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call) Run(run func()) *MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call

func (*MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call) RunAndReturn(run func() *cache.InventoryCache) *MockTenantAwareInventoryClient_TestGetClientCacheUUID_Call

type MockTenantAwareInventoryClient_TestGetClientCache_Call 

type MockTenantAwareInventoryClient_TestGetClientCache_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_TestGetClientCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestGetClientCache'

func (*MockTenantAwareInventoryClient_TestGetClientCache_Call) Return 

func (_c *MockTenantAwareInventoryClient_TestGetClientCache_Call) Return(_a0 *cache.InventoryCache) *MockTenantAwareInventoryClient_TestGetClientCache_Call

func (*MockTenantAwareInventoryClient_TestGetClientCache_Call) Run 

func (_c *MockTenantAwareInventoryClient_TestGetClientCache_Call) Run(run func()) *MockTenantAwareInventoryClient_TestGetClientCache_Call

func (*MockTenantAwareInventoryClient_TestGetClientCache_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_TestGetClientCache_Call) RunAndReturn(run func() *cache.InventoryCache) *MockTenantAwareInventoryClient_TestGetClientCache_Call

type MockTenantAwareInventoryClient_TestingOnlySetClient_Call 

type MockTenantAwareInventoryClient_TestingOnlySetClient_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_TestingOnlySetClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestingOnlySetClient'

func (*MockTenantAwareInventoryClient_TestingOnlySetClient_Call) Return 

func (_c *MockTenantAwareInventoryClient_TestingOnlySetClient_Call) Return() *MockTenantAwareInventoryClient_TestingOnlySetClient_Call

func (*MockTenantAwareInventoryClient_TestingOnlySetClient_Call) Run 

func (_c *MockTenantAwareInventoryClient_TestingOnlySetClient_Call) Run(run func(_a0 inventoryv1.InventoryServiceClient)) *MockTenantAwareInventoryClient_TestingOnlySetClient_Call

func (*MockTenantAwareInventoryClient_TestingOnlySetClient_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_TestingOnlySetClient_Call) RunAndReturn(run func(inventoryv1.InventoryServiceClient)) *MockTenantAwareInventoryClient_TestingOnlySetClient_Call

type MockTenantAwareInventoryClient_UpdateSubscriptions_Call 

type MockTenantAwareInventoryClient_UpdateSubscriptions_Call struct {
	*mock.Call
}

MockTenantAwareInventoryClient_UpdateSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSubscriptions'

func (*MockTenantAwareInventoryClient_UpdateSubscriptions_Call) Return 

func (_c *MockTenantAwareInventoryClient_UpdateSubscriptions_Call) Return(_a0 error) *MockTenantAwareInventoryClient_UpdateSubscriptions_Call

func (*MockTenantAwareInventoryClient_UpdateSubscriptions_Call) Run 

func (_c *MockTenantAwareInventoryClient_UpdateSubscriptions_Call) Run(run func(ctx context.Context, tenantID string, kinds []inventoryv1.ResourceKind)) *MockTenantAwareInventoryClient_UpdateSubscriptions_Call

func (*MockTenantAwareInventoryClient_UpdateSubscriptions_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_UpdateSubscriptions_Call) RunAndReturn(run func(context.Context, string, []inventoryv1.ResourceKind) error) *MockTenantAwareInventoryClient_UpdateSubscriptions_Call

type MockTenantAwareInventoryClient_Update_Call 

type MockTenantAwareInventoryClient_Update_Call struct {
	*mock.Call
}

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

func (*MockTenantAwareInventoryClient_Update_Call) Return 

func (_c *MockTenantAwareInventoryClient_Update_Call) Return(_a0 *inventoryv1.Resource, _a1 error) *MockTenantAwareInventoryClient_Update_Call

func (*MockTenantAwareInventoryClient_Update_Call) Run 

func (_c *MockTenantAwareInventoryClient_Update_Call) Run(run func(ctx context.Context, tenantID string, id string, fm *fieldmaskpb.FieldMask, res *inventoryv1.Resource)) *MockTenantAwareInventoryClient_Update_Call

func (*MockTenantAwareInventoryClient_Update_Call) RunAndReturn 

func (_c *MockTenantAwareInventoryClient_Update_Call) RunAndReturn(run func(context.Context, string, string, *fieldmaskpb.FieldMask, *inventoryv1.Resource) (*inventoryv1.Resource, error)) *MockTenantAwareInventoryClient_Update_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.