Documentation

Overview

    Package fake has the automatically generated clients.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type FakeComponentStatuses

    type FakeComponentStatuses struct {
    	Fake *FakeCoreV1
    }

      FakeComponentStatuses implements ComponentStatusInterface

      func (*FakeComponentStatuses) Create

      func (c *FakeComponentStatuses) Create(componentStatus *corev1.ComponentStatus) (result *corev1.ComponentStatus, err error)

        Create takes the representation of a componentStatus and creates it. Returns the server's representation of the componentStatus, and an error, if there is any.

        func (*FakeComponentStatuses) Delete

        func (c *FakeComponentStatuses) Delete(name string, options *v1.DeleteOptions) error

          Delete takes name of the componentStatus and deletes it. Returns an error if one occurs.

          func (*FakeComponentStatuses) DeleteCollection

          func (c *FakeComponentStatuses) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

            DeleteCollection deletes a collection of objects.

            func (*FakeComponentStatuses) Get

            func (c *FakeComponentStatuses) Get(name string, options v1.GetOptions) (result *corev1.ComponentStatus, err error)

              Get takes name of the componentStatus, and returns the corresponding componentStatus object, and an error if there is any.

              func (*FakeComponentStatuses) List

              func (c *FakeComponentStatuses) List(opts v1.ListOptions) (result *corev1.ComponentStatusList, err error)

                List takes label and field selectors, and returns the list of ComponentStatuses that match those selectors.

                func (*FakeComponentStatuses) Patch

                func (c *FakeComponentStatuses) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ComponentStatus, err error)

                  Patch applies the patch and returns the patched componentStatus.

                  func (*FakeComponentStatuses) Update

                  func (c *FakeComponentStatuses) Update(componentStatus *corev1.ComponentStatus) (result *corev1.ComponentStatus, err error)

                    Update takes the representation of a componentStatus and updates it. Returns the server's representation of the componentStatus, and an error, if there is any.

                    func (*FakeComponentStatuses) Watch

                      Watch returns a watch.Interface that watches the requested componentStatuses.

                      type FakeConfigMaps

                      type FakeConfigMaps struct {
                      	Fake *FakeCoreV1
                      	// contains filtered or unexported fields
                      }

                        FakeConfigMaps implements ConfigMapInterface

                        func (*FakeConfigMaps) Create

                        func (c *FakeConfigMaps) Create(configMap *corev1.ConfigMap) (result *corev1.ConfigMap, err error)

                          Create takes the representation of a configMap and creates it. Returns the server's representation of the configMap, and an error, if there is any.

                          func (*FakeConfigMaps) Delete

                          func (c *FakeConfigMaps) Delete(name string, options *v1.DeleteOptions) error

                            Delete takes name of the configMap and deletes it. Returns an error if one occurs.

                            func (*FakeConfigMaps) DeleteCollection

                            func (c *FakeConfigMaps) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                              DeleteCollection deletes a collection of objects.

                              func (*FakeConfigMaps) Get

                              func (c *FakeConfigMaps) Get(name string, options v1.GetOptions) (result *corev1.ConfigMap, err error)

                                Get takes name of the configMap, and returns the corresponding configMap object, and an error if there is any.

                                func (*FakeConfigMaps) List

                                func (c *FakeConfigMaps) List(opts v1.ListOptions) (result *corev1.ConfigMapList, err error)

                                  List takes label and field selectors, and returns the list of ConfigMaps that match those selectors.

                                  func (*FakeConfigMaps) Patch

                                  func (c *FakeConfigMaps) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ConfigMap, err error)

                                    Patch applies the patch and returns the patched configMap.

                                    func (*FakeConfigMaps) Update

                                    func (c *FakeConfigMaps) Update(configMap *corev1.ConfigMap) (result *corev1.ConfigMap, err error)

                                      Update takes the representation of a configMap and updates it. Returns the server's representation of the configMap, and an error, if there is any.

                                      func (*FakeConfigMaps) Watch

                                      func (c *FakeConfigMaps) Watch(opts v1.ListOptions) (watch.Interface, error)

                                        Watch returns a watch.Interface that watches the requested configMaps.

                                        type FakeCoreV1

                                        type FakeCoreV1 struct {
                                        	*testing.Fake
                                        }

                                        func (*FakeCoreV1) ComponentStatuses

                                        func (c *FakeCoreV1) ComponentStatuses() v1.ComponentStatusInterface

                                        func (*FakeCoreV1) ConfigMaps

                                        func (c *FakeCoreV1) ConfigMaps(namespace string) v1.ConfigMapInterface

                                        func (*FakeCoreV1) Endpoints

                                        func (c *FakeCoreV1) Endpoints(namespace string) v1.EndpointsInterface

                                        func (*FakeCoreV1) Events

                                        func (c *FakeCoreV1) Events(namespace string) v1.EventInterface

                                        func (*FakeCoreV1) LimitRanges

                                        func (c *FakeCoreV1) LimitRanges(namespace string) v1.LimitRangeInterface

                                        func (*FakeCoreV1) Namespaces

                                        func (c *FakeCoreV1) Namespaces() v1.NamespaceInterface

                                        func (*FakeCoreV1) Nodes

                                        func (c *FakeCoreV1) Nodes() v1.NodeInterface

                                        func (*FakeCoreV1) PersistentVolumeClaims

                                        func (c *FakeCoreV1) PersistentVolumeClaims(namespace string) v1.PersistentVolumeClaimInterface

                                        func (*FakeCoreV1) PersistentVolumes

                                        func (c *FakeCoreV1) PersistentVolumes() v1.PersistentVolumeInterface

                                        func (*FakeCoreV1) PodTemplates

                                        func (c *FakeCoreV1) PodTemplates(namespace string) v1.PodTemplateInterface

                                        func (*FakeCoreV1) Pods

                                        func (c *FakeCoreV1) Pods(namespace string) v1.PodInterface

                                        func (*FakeCoreV1) RESTClient

                                        func (c *FakeCoreV1) RESTClient() rest.Interface

                                          RESTClient returns a RESTClient that is used to communicate with API server by this client implementation.

                                          func (*FakeCoreV1) ReplicationControllers

                                          func (c *FakeCoreV1) ReplicationControllers(namespace string) v1.ReplicationControllerInterface

                                          func (*FakeCoreV1) ResourceQuotas

                                          func (c *FakeCoreV1) ResourceQuotas(namespace string) v1.ResourceQuotaInterface

                                          func (*FakeCoreV1) Secrets

                                          func (c *FakeCoreV1) Secrets(namespace string) v1.SecretInterface

                                          func (*FakeCoreV1) ServiceAccounts

                                          func (c *FakeCoreV1) ServiceAccounts(namespace string) v1.ServiceAccountInterface

                                          func (*FakeCoreV1) Services

                                          func (c *FakeCoreV1) Services(namespace string) v1.ServiceInterface

                                          type FakeEndpoints

                                          type FakeEndpoints struct {
                                          	Fake *FakeCoreV1
                                          	// contains filtered or unexported fields
                                          }

                                            FakeEndpoints implements EndpointsInterface

                                            func (*FakeEndpoints) Create

                                            func (c *FakeEndpoints) Create(endpoints *corev1.Endpoints) (result *corev1.Endpoints, err error)

                                              Create takes the representation of a endpoints and creates it. Returns the server's representation of the endpoints, and an error, if there is any.

                                              func (*FakeEndpoints) Delete

                                              func (c *FakeEndpoints) Delete(name string, options *v1.DeleteOptions) error

                                                Delete takes name of the endpoints and deletes it. Returns an error if one occurs.

                                                func (*FakeEndpoints) DeleteCollection

                                                func (c *FakeEndpoints) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                  DeleteCollection deletes a collection of objects.

                                                  func (*FakeEndpoints) Get

                                                  func (c *FakeEndpoints) Get(name string, options v1.GetOptions) (result *corev1.Endpoints, err error)

                                                    Get takes name of the endpoints, and returns the corresponding endpoints object, and an error if there is any.

                                                    func (*FakeEndpoints) List

                                                    func (c *FakeEndpoints) List(opts v1.ListOptions) (result *corev1.EndpointsList, err error)

                                                      List takes label and field selectors, and returns the list of Endpoints that match those selectors.

                                                      func (*FakeEndpoints) Patch

                                                      func (c *FakeEndpoints) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Endpoints, err error)

                                                        Patch applies the patch and returns the patched endpoints.

                                                        func (*FakeEndpoints) Update

                                                        func (c *FakeEndpoints) Update(endpoints *corev1.Endpoints) (result *corev1.Endpoints, err error)

                                                          Update takes the representation of a endpoints and updates it. Returns the server's representation of the endpoints, and an error, if there is any.

                                                          func (*FakeEndpoints) Watch

                                                          func (c *FakeEndpoints) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                            Watch returns a watch.Interface that watches the requested endpoints.

                                                            type FakeEvents

                                                            type FakeEvents struct {
                                                            	Fake *FakeCoreV1
                                                            	// contains filtered or unexported fields
                                                            }

                                                              FakeEvents implements EventInterface

                                                              func (*FakeEvents) Create

                                                              func (c *FakeEvents) Create(event *corev1.Event) (result *corev1.Event, err error)

                                                                Create takes the representation of a event and creates it. Returns the server's representation of the event, and an error, if there is any.

                                                                func (*FakeEvents) CreateWithEventNamespace

                                                                func (c *FakeEvents) CreateWithEventNamespace(event *v1.Event) (*v1.Event, error)

                                                                func (*FakeEvents) Delete

                                                                func (c *FakeEvents) Delete(name string, options *v1.DeleteOptions) error

                                                                  Delete takes name of the event and deletes it. Returns an error if one occurs.

                                                                  func (*FakeEvents) DeleteCollection

                                                                  func (c *FakeEvents) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                    DeleteCollection deletes a collection of objects.

                                                                    func (*FakeEvents) Get

                                                                    func (c *FakeEvents) Get(name string, options v1.GetOptions) (result *corev1.Event, err error)

                                                                      Get takes name of the event, and returns the corresponding event object, and an error if there is any.

                                                                      func (*FakeEvents) GetFieldSelector

                                                                      func (c *FakeEvents) GetFieldSelector(involvedObjectName, involvedObjectNamespace, involvedObjectKind, involvedObjectUID *string) fields.Selector

                                                                      func (*FakeEvents) List

                                                                      func (c *FakeEvents) List(opts v1.ListOptions) (result *corev1.EventList, err error)

                                                                        List takes label and field selectors, and returns the list of Events that match those selectors.

                                                                        func (*FakeEvents) Patch

                                                                        func (c *FakeEvents) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Event, err error)

                                                                          Patch applies the patch and returns the patched event.

                                                                          func (*FakeEvents) PatchWithEventNamespace

                                                                          func (c *FakeEvents) PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.Event, error)

                                                                            PatchWithEventNamespace patches an existing event. Returns the copy of the event the server returns, or an error. TODO: Should take a PatchType as an argument probably.

                                                                            func (*FakeEvents) Search

                                                                            func (c *FakeEvents) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.EventList, error)

                                                                              Search returns a list of events matching the specified object.

                                                                              func (*FakeEvents) Update

                                                                              func (c *FakeEvents) Update(event *corev1.Event) (result *corev1.Event, err error)

                                                                                Update takes the representation of a event and updates it. Returns the server's representation of the event, and an error, if there is any.

                                                                                func (*FakeEvents) UpdateWithEventNamespace

                                                                                func (c *FakeEvents) UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error)

                                                                                  Update replaces an existing event. Returns the copy of the event the server returns, or an error.

                                                                                  func (*FakeEvents) Watch

                                                                                  func (c *FakeEvents) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                                                    Watch returns a watch.Interface that watches the requested events.

                                                                                    type FakeLimitRanges

                                                                                    type FakeLimitRanges struct {
                                                                                    	Fake *FakeCoreV1
                                                                                    	// contains filtered or unexported fields
                                                                                    }

                                                                                      FakeLimitRanges implements LimitRangeInterface

                                                                                      func (*FakeLimitRanges) Create

                                                                                      func (c *FakeLimitRanges) Create(limitRange *corev1.LimitRange) (result *corev1.LimitRange, err error)

                                                                                        Create takes the representation of a limitRange and creates it. Returns the server's representation of the limitRange, and an error, if there is any.

                                                                                        func (*FakeLimitRanges) Delete

                                                                                        func (c *FakeLimitRanges) Delete(name string, options *v1.DeleteOptions) error

                                                                                          Delete takes name of the limitRange and deletes it. Returns an error if one occurs.

                                                                                          func (*FakeLimitRanges) DeleteCollection

                                                                                          func (c *FakeLimitRanges) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                            DeleteCollection deletes a collection of objects.

                                                                                            func (*FakeLimitRanges) Get

                                                                                            func (c *FakeLimitRanges) Get(name string, options v1.GetOptions) (result *corev1.LimitRange, err error)

                                                                                              Get takes name of the limitRange, and returns the corresponding limitRange object, and an error if there is any.

                                                                                              func (*FakeLimitRanges) List

                                                                                              func (c *FakeLimitRanges) List(opts v1.ListOptions) (result *corev1.LimitRangeList, err error)

                                                                                                List takes label and field selectors, and returns the list of LimitRanges that match those selectors.

                                                                                                func (*FakeLimitRanges) Patch

                                                                                                func (c *FakeLimitRanges) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.LimitRange, err error)

                                                                                                  Patch applies the patch and returns the patched limitRange.

                                                                                                  func (*FakeLimitRanges) Update

                                                                                                  func (c *FakeLimitRanges) Update(limitRange *corev1.LimitRange) (result *corev1.LimitRange, err error)

                                                                                                    Update takes the representation of a limitRange and updates it. Returns the server's representation of the limitRange, and an error, if there is any.

                                                                                                    func (*FakeLimitRanges) Watch

                                                                                                    func (c *FakeLimitRanges) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                                                                      Watch returns a watch.Interface that watches the requested limitRanges.

                                                                                                      type FakeNamespaces

                                                                                                      type FakeNamespaces struct {
                                                                                                      	Fake *FakeCoreV1
                                                                                                      }

                                                                                                        FakeNamespaces implements NamespaceInterface

                                                                                                        func (*FakeNamespaces) Create

                                                                                                        func (c *FakeNamespaces) Create(namespace *corev1.Namespace) (result *corev1.Namespace, err error)

                                                                                                          Create takes the representation of a namespace and creates it. Returns the server's representation of the namespace, and an error, if there is any.

                                                                                                          func (*FakeNamespaces) Delete

                                                                                                          func (c *FakeNamespaces) Delete(name string, options *v1.DeleteOptions) error

                                                                                                            Delete takes name of the namespace and deletes it. Returns an error if one occurs.

                                                                                                            func (*FakeNamespaces) Finalize

                                                                                                            func (c *FakeNamespaces) Finalize(namespace *v1.Namespace) (*v1.Namespace, error)

                                                                                                            func (*FakeNamespaces) Get

                                                                                                            func (c *FakeNamespaces) Get(name string, options v1.GetOptions) (result *corev1.Namespace, err error)

                                                                                                              Get takes name of the namespace, and returns the corresponding namespace object, and an error if there is any.

                                                                                                              func (*FakeNamespaces) List

                                                                                                              func (c *FakeNamespaces) List(opts v1.ListOptions) (result *corev1.NamespaceList, err error)

                                                                                                                List takes label and field selectors, and returns the list of Namespaces that match those selectors.

                                                                                                                func (*FakeNamespaces) Patch

                                                                                                                func (c *FakeNamespaces) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Namespace, err error)

                                                                                                                  Patch applies the patch and returns the patched namespace.

                                                                                                                  func (*FakeNamespaces) Update

                                                                                                                  func (c *FakeNamespaces) Update(namespace *corev1.Namespace) (result *corev1.Namespace, err error)

                                                                                                                    Update takes the representation of a namespace and updates it. Returns the server's representation of the namespace, and an error, if there is any.

                                                                                                                    func (*FakeNamespaces) UpdateStatus

                                                                                                                    func (c *FakeNamespaces) UpdateStatus(namespace *corev1.Namespace) (*corev1.Namespace, error)

                                                                                                                      UpdateStatus was generated because the type contains a Status member. Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().

                                                                                                                      func (*FakeNamespaces) Watch

                                                                                                                      func (c *FakeNamespaces) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                                                                                        Watch returns a watch.Interface that watches the requested namespaces.

                                                                                                                        type FakeNodes

                                                                                                                        type FakeNodes struct {
                                                                                                                        	Fake *FakeCoreV1
                                                                                                                        }

                                                                                                                          FakeNodes implements NodeInterface

                                                                                                                          func (*FakeNodes) Create

                                                                                                                          func (c *FakeNodes) Create(node *corev1.Node) (result *corev1.Node, err error)

                                                                                                                            Create takes the representation of a node and creates it. Returns the server's representation of the node, and an error, if there is any.

                                                                                                                            func (*FakeNodes) Delete

                                                                                                                            func (c *FakeNodes) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                              Delete takes name of the node and deletes it. Returns an error if one occurs.

                                                                                                                              func (*FakeNodes) DeleteCollection

                                                                                                                              func (c *FakeNodes) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                DeleteCollection deletes a collection of objects.

                                                                                                                                func (*FakeNodes) Get

                                                                                                                                func (c *FakeNodes) Get(name string, options v1.GetOptions) (result *corev1.Node, err error)

                                                                                                                                  Get takes name of the node, and returns the corresponding node object, and an error if there is any.

                                                                                                                                  func (*FakeNodes) List

                                                                                                                                  func (c *FakeNodes) List(opts v1.ListOptions) (result *corev1.NodeList, err error)

                                                                                                                                    List takes label and field selectors, and returns the list of Nodes that match those selectors.

                                                                                                                                    func (*FakeNodes) Patch

                                                                                                                                    func (c *FakeNodes) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Node, err error)

                                                                                                                                      Patch applies the patch and returns the patched node.

                                                                                                                                      func (*FakeNodes) PatchStatus

                                                                                                                                      func (c *FakeNodes) PatchStatus(nodeName string, data []byte) (*v1.Node, error)

                                                                                                                                        TODO: Should take a PatchType as an argument probably.

                                                                                                                                        func (*FakeNodes) Update

                                                                                                                                        func (c *FakeNodes) Update(node *corev1.Node) (result *corev1.Node, err error)

                                                                                                                                          Update takes the representation of a node and updates it. Returns the server's representation of the node, and an error, if there is any.

                                                                                                                                          func (*FakeNodes) UpdateStatus

                                                                                                                                          func (c *FakeNodes) UpdateStatus(node *corev1.Node) (*corev1.Node, error)

                                                                                                                                            UpdateStatus was generated because the type contains a Status member. Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().

                                                                                                                                            func (*FakeNodes) Watch

                                                                                                                                            func (c *FakeNodes) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                                                                                                              Watch returns a watch.Interface that watches the requested nodes.

                                                                                                                                              type FakePersistentVolumeClaims

                                                                                                                                              type FakePersistentVolumeClaims struct {
                                                                                                                                              	Fake *FakeCoreV1
                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                              }

                                                                                                                                                FakePersistentVolumeClaims implements PersistentVolumeClaimInterface

                                                                                                                                                func (*FakePersistentVolumeClaims) Create

                                                                                                                                                func (c *FakePersistentVolumeClaims) Create(persistentVolumeClaim *corev1.PersistentVolumeClaim) (result *corev1.PersistentVolumeClaim, err error)

                                                                                                                                                  Create takes the representation of a persistentVolumeClaim and creates it. Returns the server's representation of the persistentVolumeClaim, and an error, if there is any.

                                                                                                                                                  func (*FakePersistentVolumeClaims) Delete

                                                                                                                                                  func (c *FakePersistentVolumeClaims) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                    Delete takes name of the persistentVolumeClaim and deletes it. Returns an error if one occurs.

                                                                                                                                                    func (*FakePersistentVolumeClaims) DeleteCollection

                                                                                                                                                    func (c *FakePersistentVolumeClaims) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                                      DeleteCollection deletes a collection of objects.

                                                                                                                                                      func (*FakePersistentVolumeClaims) Get

                                                                                                                                                      func (c *FakePersistentVolumeClaims) Get(name string, options v1.GetOptions) (result *corev1.PersistentVolumeClaim, err error)

                                                                                                                                                        Get takes name of the persistentVolumeClaim, and returns the corresponding persistentVolumeClaim object, and an error if there is any.

                                                                                                                                                        func (*FakePersistentVolumeClaims) List

                                                                                                                                                          List takes label and field selectors, and returns the list of PersistentVolumeClaims that match those selectors.

                                                                                                                                                          func (*FakePersistentVolumeClaims) Patch

                                                                                                                                                          func (c *FakePersistentVolumeClaims) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.PersistentVolumeClaim, err error)

                                                                                                                                                            Patch applies the patch and returns the patched persistentVolumeClaim.

                                                                                                                                                            func (*FakePersistentVolumeClaims) Update

                                                                                                                                                            func (c *FakePersistentVolumeClaims) Update(persistentVolumeClaim *corev1.PersistentVolumeClaim) (result *corev1.PersistentVolumeClaim, err error)

                                                                                                                                                              Update takes the representation of a persistentVolumeClaim and updates it. Returns the server's representation of the persistentVolumeClaim, and an error, if there is any.

                                                                                                                                                              func (*FakePersistentVolumeClaims) UpdateStatus

                                                                                                                                                              func (c *FakePersistentVolumeClaims) UpdateStatus(persistentVolumeClaim *corev1.PersistentVolumeClaim) (*corev1.PersistentVolumeClaim, error)

                                                                                                                                                                UpdateStatus was generated because the type contains a Status member. Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().

                                                                                                                                                                func (*FakePersistentVolumeClaims) Watch

                                                                                                                                                                  Watch returns a watch.Interface that watches the requested persistentVolumeClaims.

                                                                                                                                                                  type FakePersistentVolumes

                                                                                                                                                                  type FakePersistentVolumes struct {
                                                                                                                                                                  	Fake *FakeCoreV1
                                                                                                                                                                  }

                                                                                                                                                                    FakePersistentVolumes implements PersistentVolumeInterface

                                                                                                                                                                    func (*FakePersistentVolumes) Create

                                                                                                                                                                    func (c *FakePersistentVolumes) Create(persistentVolume *corev1.PersistentVolume) (result *corev1.PersistentVolume, err error)

                                                                                                                                                                      Create takes the representation of a persistentVolume and creates it. Returns the server's representation of the persistentVolume, and an error, if there is any.

                                                                                                                                                                      func (*FakePersistentVolumes) Delete

                                                                                                                                                                      func (c *FakePersistentVolumes) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                                        Delete takes name of the persistentVolume and deletes it. Returns an error if one occurs.

                                                                                                                                                                        func (*FakePersistentVolumes) DeleteCollection

                                                                                                                                                                        func (c *FakePersistentVolumes) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                                                          DeleteCollection deletes a collection of objects.

                                                                                                                                                                          func (*FakePersistentVolumes) Get

                                                                                                                                                                          func (c *FakePersistentVolumes) Get(name string, options v1.GetOptions) (result *corev1.PersistentVolume, err error)

                                                                                                                                                                            Get takes name of the persistentVolume, and returns the corresponding persistentVolume object, and an error if there is any.

                                                                                                                                                                            func (*FakePersistentVolumes) List

                                                                                                                                                                              List takes label and field selectors, and returns the list of PersistentVolumes that match those selectors.

                                                                                                                                                                              func (*FakePersistentVolumes) Patch

                                                                                                                                                                              func (c *FakePersistentVolumes) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.PersistentVolume, err error)

                                                                                                                                                                                Patch applies the patch and returns the patched persistentVolume.

                                                                                                                                                                                func (*FakePersistentVolumes) Update

                                                                                                                                                                                func (c *FakePersistentVolumes) Update(persistentVolume *corev1.PersistentVolume) (result *corev1.PersistentVolume, err error)

                                                                                                                                                                                  Update takes the representation of a persistentVolume and updates it. Returns the server's representation of the persistentVolume, and an error, if there is any.

                                                                                                                                                                                  func (*FakePersistentVolumes) UpdateStatus

                                                                                                                                                                                  func (c *FakePersistentVolumes) UpdateStatus(persistentVolume *corev1.PersistentVolume) (*corev1.PersistentVolume, error)

                                                                                                                                                                                    UpdateStatus was generated because the type contains a Status member. Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().

                                                                                                                                                                                    func (*FakePersistentVolumes) Watch

                                                                                                                                                                                      Watch returns a watch.Interface that watches the requested persistentVolumes.

                                                                                                                                                                                      type FakePodTemplates

                                                                                                                                                                                      type FakePodTemplates struct {
                                                                                                                                                                                      	Fake *FakeCoreV1
                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                      }

                                                                                                                                                                                        FakePodTemplates implements PodTemplateInterface

                                                                                                                                                                                        func (*FakePodTemplates) Create

                                                                                                                                                                                        func (c *FakePodTemplates) Create(podTemplate *corev1.PodTemplate) (result *corev1.PodTemplate, err error)

                                                                                                                                                                                          Create takes the representation of a podTemplate and creates it. Returns the server's representation of the podTemplate, and an error, if there is any.

                                                                                                                                                                                          func (*FakePodTemplates) Delete

                                                                                                                                                                                          func (c *FakePodTemplates) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                                                            Delete takes name of the podTemplate and deletes it. Returns an error if one occurs.

                                                                                                                                                                                            func (*FakePodTemplates) DeleteCollection

                                                                                                                                                                                            func (c *FakePodTemplates) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                                                                              DeleteCollection deletes a collection of objects.

                                                                                                                                                                                              func (*FakePodTemplates) Get

                                                                                                                                                                                              func (c *FakePodTemplates) Get(name string, options v1.GetOptions) (result *corev1.PodTemplate, err error)

                                                                                                                                                                                                Get takes name of the podTemplate, and returns the corresponding podTemplate object, and an error if there is any.

                                                                                                                                                                                                func (*FakePodTemplates) List

                                                                                                                                                                                                func (c *FakePodTemplates) List(opts v1.ListOptions) (result *corev1.PodTemplateList, err error)

                                                                                                                                                                                                  List takes label and field selectors, and returns the list of PodTemplates that match those selectors.

                                                                                                                                                                                                  func (*FakePodTemplates) Patch

                                                                                                                                                                                                  func (c *FakePodTemplates) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.PodTemplate, err error)

                                                                                                                                                                                                    Patch applies the patch and returns the patched podTemplate.

                                                                                                                                                                                                    func (*FakePodTemplates) Update

                                                                                                                                                                                                    func (c *FakePodTemplates) Update(podTemplate *corev1.PodTemplate) (result *corev1.PodTemplate, err error)

                                                                                                                                                                                                      Update takes the representation of a podTemplate and updates it. Returns the server's representation of the podTemplate, and an error, if there is any.

                                                                                                                                                                                                      func (*FakePodTemplates) Watch

                                                                                                                                                                                                      func (c *FakePodTemplates) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                                                                                                                                                                        Watch returns a watch.Interface that watches the requested podTemplates.

                                                                                                                                                                                                        type FakePods

                                                                                                                                                                                                        type FakePods struct {
                                                                                                                                                                                                        	Fake *FakeCoreV1
                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                        }

                                                                                                                                                                                                          FakePods implements PodInterface

                                                                                                                                                                                                          func (*FakePods) Bind

                                                                                                                                                                                                          func (c *FakePods) Bind(binding *v1.Binding) error

                                                                                                                                                                                                          func (*FakePods) Create

                                                                                                                                                                                                          func (c *FakePods) Create(pod *corev1.Pod) (result *corev1.Pod, err error)

                                                                                                                                                                                                            Create takes the representation of a pod and creates it. Returns the server's representation of the pod, and an error, if there is any.

                                                                                                                                                                                                            func (*FakePods) Delete

                                                                                                                                                                                                            func (c *FakePods) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                                                                              Delete takes name of the pod and deletes it. Returns an error if one occurs.

                                                                                                                                                                                                              func (*FakePods) DeleteCollection

                                                                                                                                                                                                              func (c *FakePods) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                                                                                                DeleteCollection deletes a collection of objects.

                                                                                                                                                                                                                func (*FakePods) Evict

                                                                                                                                                                                                                func (c *FakePods) Evict(eviction *policy.Eviction) error

                                                                                                                                                                                                                func (*FakePods) Get

                                                                                                                                                                                                                func (c *FakePods) Get(name string, options v1.GetOptions) (result *corev1.Pod, err error)

                                                                                                                                                                                                                  Get takes name of the pod, and returns the corresponding pod object, and an error if there is any.

                                                                                                                                                                                                                  func (*FakePods) GetBinding

                                                                                                                                                                                                                  func (c *FakePods) GetBinding(name string) (result *v1.Binding, err error)

                                                                                                                                                                                                                  func (*FakePods) GetEphemeralContainers

                                                                                                                                                                                                                  func (c *FakePods) GetEphemeralContainers(podName string, options v1.GetOptions) (result *corev1.EphemeralContainers, err error)

                                                                                                                                                                                                                    GetEphemeralContainers takes name of the pod, and returns the corresponding ephemeralContainers object, and an error if there is any.

                                                                                                                                                                                                                    func (*FakePods) GetLogs

                                                                                                                                                                                                                    func (c *FakePods) GetLogs(name string, opts *v1.PodLogOptions) *restclient.Request

                                                                                                                                                                                                                    func (*FakePods) List

                                                                                                                                                                                                                    func (c *FakePods) List(opts v1.ListOptions) (result *corev1.PodList, err error)

                                                                                                                                                                                                                      List takes label and field selectors, and returns the list of Pods that match those selectors.

                                                                                                                                                                                                                      func (*FakePods) Patch

                                                                                                                                                                                                                      func (c *FakePods) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Pod, err error)

                                                                                                                                                                                                                        Patch applies the patch and returns the patched pod.

                                                                                                                                                                                                                        func (*FakePods) Update

                                                                                                                                                                                                                        func (c *FakePods) Update(pod *corev1.Pod) (result *corev1.Pod, err error)

                                                                                                                                                                                                                          Update takes the representation of a pod and updates it. Returns the server's representation of the pod, and an error, if there is any.

                                                                                                                                                                                                                          func (*FakePods) UpdateEphemeralContainers

                                                                                                                                                                                                                          func (c *FakePods) UpdateEphemeralContainers(podName string, ephemeralContainers *corev1.EphemeralContainers) (result *corev1.EphemeralContainers, err error)

                                                                                                                                                                                                                            UpdateEphemeralContainers takes the representation of a ephemeralContainers and updates it. Returns the server's representation of the ephemeralContainers, and an error, if there is any.

                                                                                                                                                                                                                            func (*FakePods) UpdateStatus

                                                                                                                                                                                                                            func (c *FakePods) UpdateStatus(pod *corev1.Pod) (*corev1.Pod, error)

                                                                                                                                                                                                                              UpdateStatus was generated because the type contains a Status member. Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().

                                                                                                                                                                                                                              func (*FakePods) Watch

                                                                                                                                                                                                                              func (c *FakePods) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                                                                                                                                                                                                Watch returns a watch.Interface that watches the requested pods.

                                                                                                                                                                                                                                type FakeReplicationControllers

                                                                                                                                                                                                                                type FakeReplicationControllers struct {
                                                                                                                                                                                                                                	Fake *FakeCoreV1
                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  FakeReplicationControllers implements ReplicationControllerInterface

                                                                                                                                                                                                                                  func (*FakeReplicationControllers) Create

                                                                                                                                                                                                                                  func (c *FakeReplicationControllers) Create(replicationController *corev1.ReplicationController) (result *corev1.ReplicationController, err error)

                                                                                                                                                                                                                                    Create takes the representation of a replicationController and creates it. Returns the server's representation of the replicationController, and an error, if there is any.

                                                                                                                                                                                                                                    func (*FakeReplicationControllers) Delete

                                                                                                                                                                                                                                    func (c *FakeReplicationControllers) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                                                                                                      Delete takes name of the replicationController and deletes it. Returns an error if one occurs.

                                                                                                                                                                                                                                      func (*FakeReplicationControllers) DeleteCollection

                                                                                                                                                                                                                                      func (c *FakeReplicationControllers) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                                                                                                                        DeleteCollection deletes a collection of objects.

                                                                                                                                                                                                                                        func (*FakeReplicationControllers) Get

                                                                                                                                                                                                                                        func (c *FakeReplicationControllers) Get(name string, options v1.GetOptions) (result *corev1.ReplicationController, err error)

                                                                                                                                                                                                                                          Get takes name of the replicationController, and returns the corresponding replicationController object, and an error if there is any.

                                                                                                                                                                                                                                          func (*FakeReplicationControllers) GetScale

                                                                                                                                                                                                                                          func (c *FakeReplicationControllers) GetScale(replicationControllerName string, options v1.GetOptions) (result *autoscalingv1.Scale, err error)

                                                                                                                                                                                                                                            GetScale takes name of the replicationController, and returns the corresponding scale object, and an error if there is any.

                                                                                                                                                                                                                                            func (*FakeReplicationControllers) List

                                                                                                                                                                                                                                              List takes label and field selectors, and returns the list of ReplicationControllers that match those selectors.

                                                                                                                                                                                                                                              func (*FakeReplicationControllers) Patch

                                                                                                                                                                                                                                              func (c *FakeReplicationControllers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ReplicationController, err error)

                                                                                                                                                                                                                                                Patch applies the patch and returns the patched replicationController.

                                                                                                                                                                                                                                                func (*FakeReplicationControllers) Update

                                                                                                                                                                                                                                                func (c *FakeReplicationControllers) Update(replicationController *corev1.ReplicationController) (result *corev1.ReplicationController, err error)

                                                                                                                                                                                                                                                  Update takes the representation of a replicationController and updates it. Returns the server's representation of the replicationController, and an error, if there is any.

                                                                                                                                                                                                                                                  func (*FakeReplicationControllers) UpdateScale

                                                                                                                                                                                                                                                  func (c *FakeReplicationControllers) UpdateScale(replicationControllerName string, scale *autoscalingv1.Scale) (result *autoscalingv1.Scale, err error)

                                                                                                                                                                                                                                                    UpdateScale takes the representation of a scale and updates it. Returns the server's representation of the scale, and an error, if there is any.

                                                                                                                                                                                                                                                    func (*FakeReplicationControllers) UpdateStatus

                                                                                                                                                                                                                                                    func (c *FakeReplicationControllers) UpdateStatus(replicationController *corev1.ReplicationController) (*corev1.ReplicationController, error)

                                                                                                                                                                                                                                                      UpdateStatus was generated because the type contains a Status member. Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().

                                                                                                                                                                                                                                                      func (*FakeReplicationControllers) Watch

                                                                                                                                                                                                                                                        Watch returns a watch.Interface that watches the requested replicationControllers.

                                                                                                                                                                                                                                                        type FakeResourceQuotas

                                                                                                                                                                                                                                                        type FakeResourceQuotas struct {
                                                                                                                                                                                                                                                        	Fake *FakeCoreV1
                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          FakeResourceQuotas implements ResourceQuotaInterface

                                                                                                                                                                                                                                                          func (*FakeResourceQuotas) Create

                                                                                                                                                                                                                                                          func (c *FakeResourceQuotas) Create(resourceQuota *corev1.ResourceQuota) (result *corev1.ResourceQuota, err error)

                                                                                                                                                                                                                                                            Create takes the representation of a resourceQuota and creates it. Returns the server's representation of the resourceQuota, and an error, if there is any.

                                                                                                                                                                                                                                                            func (*FakeResourceQuotas) Delete

                                                                                                                                                                                                                                                            func (c *FakeResourceQuotas) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                                                                                                                              Delete takes name of the resourceQuota and deletes it. Returns an error if one occurs.

                                                                                                                                                                                                                                                              func (*FakeResourceQuotas) DeleteCollection

                                                                                                                                                                                                                                                              func (c *FakeResourceQuotas) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                                                                                                                                                DeleteCollection deletes a collection of objects.

                                                                                                                                                                                                                                                                func (*FakeResourceQuotas) Get

                                                                                                                                                                                                                                                                func (c *FakeResourceQuotas) Get(name string, options v1.GetOptions) (result *corev1.ResourceQuota, err error)

                                                                                                                                                                                                                                                                  Get takes name of the resourceQuota, and returns the corresponding resourceQuota object, and an error if there is any.

                                                                                                                                                                                                                                                                  func (*FakeResourceQuotas) List

                                                                                                                                                                                                                                                                  func (c *FakeResourceQuotas) List(opts v1.ListOptions) (result *corev1.ResourceQuotaList, err error)

                                                                                                                                                                                                                                                                    List takes label and field selectors, and returns the list of ResourceQuotas that match those selectors.

                                                                                                                                                                                                                                                                    func (*FakeResourceQuotas) Patch

                                                                                                                                                                                                                                                                    func (c *FakeResourceQuotas) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ResourceQuota, err error)

                                                                                                                                                                                                                                                                      Patch applies the patch and returns the patched resourceQuota.

                                                                                                                                                                                                                                                                      func (*FakeResourceQuotas) Update

                                                                                                                                                                                                                                                                      func (c *FakeResourceQuotas) Update(resourceQuota *corev1.ResourceQuota) (result *corev1.ResourceQuota, err error)

                                                                                                                                                                                                                                                                        Update takes the representation of a resourceQuota and updates it. Returns the server's representation of the resourceQuota, and an error, if there is any.

                                                                                                                                                                                                                                                                        func (*FakeResourceQuotas) UpdateStatus

                                                                                                                                                                                                                                                                        func (c *FakeResourceQuotas) UpdateStatus(resourceQuota *corev1.ResourceQuota) (*corev1.ResourceQuota, error)

                                                                                                                                                                                                                                                                          UpdateStatus was generated because the type contains a Status member. Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().

                                                                                                                                                                                                                                                                          func (*FakeResourceQuotas) Watch

                                                                                                                                                                                                                                                                            Watch returns a watch.Interface that watches the requested resourceQuotas.

                                                                                                                                                                                                                                                                            type FakeSecrets

                                                                                                                                                                                                                                                                            type FakeSecrets struct {
                                                                                                                                                                                                                                                                            	Fake *FakeCoreV1
                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              FakeSecrets implements SecretInterface

                                                                                                                                                                                                                                                                              func (*FakeSecrets) Create

                                                                                                                                                                                                                                                                              func (c *FakeSecrets) Create(secret *corev1.Secret) (result *corev1.Secret, err error)

                                                                                                                                                                                                                                                                                Create takes the representation of a secret and creates it. Returns the server's representation of the secret, and an error, if there is any.

                                                                                                                                                                                                                                                                                func (*FakeSecrets) Delete

                                                                                                                                                                                                                                                                                func (c *FakeSecrets) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                                                                                                                                                  Delete takes name of the secret and deletes it. Returns an error if one occurs.

                                                                                                                                                                                                                                                                                  func (*FakeSecrets) DeleteCollection

                                                                                                                                                                                                                                                                                  func (c *FakeSecrets) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                                                                                                                                                                    DeleteCollection deletes a collection of objects.

                                                                                                                                                                                                                                                                                    func (*FakeSecrets) Get

                                                                                                                                                                                                                                                                                    func (c *FakeSecrets) Get(name string, options v1.GetOptions) (result *corev1.Secret, err error)

                                                                                                                                                                                                                                                                                      Get takes name of the secret, and returns the corresponding secret object, and an error if there is any.

                                                                                                                                                                                                                                                                                      func (*FakeSecrets) List

                                                                                                                                                                                                                                                                                      func (c *FakeSecrets) List(opts v1.ListOptions) (result *corev1.SecretList, err error)

                                                                                                                                                                                                                                                                                        List takes label and field selectors, and returns the list of Secrets that match those selectors.

                                                                                                                                                                                                                                                                                        func (*FakeSecrets) Patch

                                                                                                                                                                                                                                                                                        func (c *FakeSecrets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Secret, err error)

                                                                                                                                                                                                                                                                                          Patch applies the patch and returns the patched secret.

                                                                                                                                                                                                                                                                                          func (*FakeSecrets) Update

                                                                                                                                                                                                                                                                                          func (c *FakeSecrets) Update(secret *corev1.Secret) (result *corev1.Secret, err error)

                                                                                                                                                                                                                                                                                            Update takes the representation of a secret and updates it. Returns the server's representation of the secret, and an error, if there is any.

                                                                                                                                                                                                                                                                                            func (*FakeSecrets) Watch

                                                                                                                                                                                                                                                                                            func (c *FakeSecrets) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                                                                                                                                                                                                                                                              Watch returns a watch.Interface that watches the requested secrets.

                                                                                                                                                                                                                                                                                              type FakeServiceAccounts

                                                                                                                                                                                                                                                                                              type FakeServiceAccounts struct {
                                                                                                                                                                                                                                                                                              	Fake *FakeCoreV1
                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                FakeServiceAccounts implements ServiceAccountInterface

                                                                                                                                                                                                                                                                                                func (*FakeServiceAccounts) Create

                                                                                                                                                                                                                                                                                                func (c *FakeServiceAccounts) Create(serviceAccount *corev1.ServiceAccount) (result *corev1.ServiceAccount, err error)

                                                                                                                                                                                                                                                                                                  Create takes the representation of a serviceAccount and creates it. Returns the server's representation of the serviceAccount, and an error, if there is any.

                                                                                                                                                                                                                                                                                                  func (*FakeServiceAccounts) CreateToken

                                                                                                                                                                                                                                                                                                  func (*FakeServiceAccounts) Delete

                                                                                                                                                                                                                                                                                                  func (c *FakeServiceAccounts) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                                                                                                                                                                    Delete takes name of the serviceAccount and deletes it. Returns an error if one occurs.

                                                                                                                                                                                                                                                                                                    func (*FakeServiceAccounts) DeleteCollection

                                                                                                                                                                                                                                                                                                    func (c *FakeServiceAccounts) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error

                                                                                                                                                                                                                                                                                                      DeleteCollection deletes a collection of objects.

                                                                                                                                                                                                                                                                                                      func (*FakeServiceAccounts) Get

                                                                                                                                                                                                                                                                                                      func (c *FakeServiceAccounts) Get(name string, options v1.GetOptions) (result *corev1.ServiceAccount, err error)

                                                                                                                                                                                                                                                                                                        Get takes name of the serviceAccount, and returns the corresponding serviceAccount object, and an error if there is any.

                                                                                                                                                                                                                                                                                                        func (*FakeServiceAccounts) List

                                                                                                                                                                                                                                                                                                        func (c *FakeServiceAccounts) List(opts v1.ListOptions) (result *corev1.ServiceAccountList, err error)

                                                                                                                                                                                                                                                                                                          List takes label and field selectors, and returns the list of ServiceAccounts that match those selectors.

                                                                                                                                                                                                                                                                                                          func (*FakeServiceAccounts) Patch

                                                                                                                                                                                                                                                                                                          func (c *FakeServiceAccounts) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ServiceAccount, err error)

                                                                                                                                                                                                                                                                                                            Patch applies the patch and returns the patched serviceAccount.

                                                                                                                                                                                                                                                                                                            func (*FakeServiceAccounts) Update

                                                                                                                                                                                                                                                                                                            func (c *FakeServiceAccounts) Update(serviceAccount *corev1.ServiceAccount) (result *corev1.ServiceAccount, err error)

                                                                                                                                                                                                                                                                                                              Update takes the representation of a serviceAccount and updates it. Returns the server's representation of the serviceAccount, and an error, if there is any.

                                                                                                                                                                                                                                                                                                              func (*FakeServiceAccounts) Watch

                                                                                                                                                                                                                                                                                                                Watch returns a watch.Interface that watches the requested serviceAccounts.

                                                                                                                                                                                                                                                                                                                type FakeServices

                                                                                                                                                                                                                                                                                                                type FakeServices struct {
                                                                                                                                                                                                                                                                                                                	Fake *FakeCoreV1
                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                  FakeServices implements ServiceInterface

                                                                                                                                                                                                                                                                                                                  func (*FakeServices) Create

                                                                                                                                                                                                                                                                                                                  func (c *FakeServices) Create(service *corev1.Service) (result *corev1.Service, err error)

                                                                                                                                                                                                                                                                                                                    Create takes the representation of a service and creates it. Returns the server's representation of the service, and an error, if there is any.

                                                                                                                                                                                                                                                                                                                    func (*FakeServices) Delete

                                                                                                                                                                                                                                                                                                                    func (c *FakeServices) Delete(name string, options *v1.DeleteOptions) error

                                                                                                                                                                                                                                                                                                                      Delete takes name of the service and deletes it. Returns an error if one occurs.

                                                                                                                                                                                                                                                                                                                      func (*FakeServices) Get

                                                                                                                                                                                                                                                                                                                      func (c *FakeServices) Get(name string, options v1.GetOptions) (result *corev1.Service, err error)

                                                                                                                                                                                                                                                                                                                        Get takes name of the service, and returns the corresponding service object, and an error if there is any.

                                                                                                                                                                                                                                                                                                                        func (*FakeServices) List

                                                                                                                                                                                                                                                                                                                        func (c *FakeServices) List(opts v1.ListOptions) (result *corev1.ServiceList, err error)

                                                                                                                                                                                                                                                                                                                          List takes label and field selectors, and returns the list of Services that match those selectors.

                                                                                                                                                                                                                                                                                                                          func (*FakeServices) Patch

                                                                                                                                                                                                                                                                                                                          func (c *FakeServices) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Service, err error)

                                                                                                                                                                                                                                                                                                                            Patch applies the patch and returns the patched service.

                                                                                                                                                                                                                                                                                                                            func (*FakeServices) ProxyGet

                                                                                                                                                                                                                                                                                                                            func (c *FakeServices) ProxyGet(scheme, name, port, path string, params map[string]string) restclient.ResponseWrapper

                                                                                                                                                                                                                                                                                                                            func (*FakeServices) Update

                                                                                                                                                                                                                                                                                                                            func (c *FakeServices) Update(service *corev1.Service) (result *corev1.Service, err error)

                                                                                                                                                                                                                                                                                                                              Update takes the representation of a service and updates it. Returns the server's representation of the service, and an error, if there is any.

                                                                                                                                                                                                                                                                                                                              func (*FakeServices) UpdateStatus

                                                                                                                                                                                                                                                                                                                              func (c *FakeServices) UpdateStatus(service *corev1.Service) (*corev1.Service, error)

                                                                                                                                                                                                                                                                                                                                UpdateStatus was generated because the type contains a Status member. Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().

                                                                                                                                                                                                                                                                                                                                func (*FakeServices) Watch

                                                                                                                                                                                                                                                                                                                                func (c *FakeServices) Watch(opts v1.ListOptions) (watch.Interface, error)

                                                                                                                                                                                                                                                                                                                                  Watch returns a watch.Interface that watches the requested services.