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 FakeClusterV1alpha1

    type FakeClusterV1alpha1 struct {
    	*testing.Fake
    }

    func (*FakeClusterV1alpha1) Clusters

    func (c *FakeClusterV1alpha1) Clusters(namespace string) v1alpha1.ClusterInterface

    func (*FakeClusterV1alpha1) MachineClasses

    func (c *FakeClusterV1alpha1) MachineClasses(namespace string) v1alpha1.MachineClassInterface

    func (*FakeClusterV1alpha1) MachineDeployments

    func (c *FakeClusterV1alpha1) MachineDeployments(namespace string) v1alpha1.MachineDeploymentInterface

    func (*FakeClusterV1alpha1) MachineSets

    func (c *FakeClusterV1alpha1) MachineSets(namespace string) v1alpha1.MachineSetInterface

    func (*FakeClusterV1alpha1) Machines

    func (c *FakeClusterV1alpha1) Machines(namespace string) v1alpha1.MachineInterface

    func (*FakeClusterV1alpha1) RESTClient

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

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

      type FakeClusters

      type FakeClusters struct {
      	Fake *FakeClusterV1alpha1
      	// contains filtered or unexported fields
      }

        FakeClusters implements ClusterInterface

        func (*FakeClusters) Create

        func (c *FakeClusters) Create(cluster *v1alpha1.Cluster) (result *v1alpha1.Cluster, err error)

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

          func (*FakeClusters) Delete

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

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

            func (*FakeClusters) DeleteCollection

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

              DeleteCollection deletes a collection of objects.

              func (*FakeClusters) Get

              func (c *FakeClusters) Get(name string, options v1.GetOptions) (result *v1alpha1.Cluster, err error)

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

                func (*FakeClusters) List

                func (c *FakeClusters) List(opts v1.ListOptions) (result *v1alpha1.ClusterList, err error)

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

                  func (*FakeClusters) Patch

                  func (c *FakeClusters) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Cluster, err error)

                    Patch applies the patch and returns the patched cluster.

                    func (*FakeClusters) Update

                    func (c *FakeClusters) Update(cluster *v1alpha1.Cluster) (result *v1alpha1.Cluster, err error)

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

                      func (*FakeClusters) UpdateStatus

                      func (c *FakeClusters) UpdateStatus(cluster *v1alpha1.Cluster) (*v1alpha1.Cluster, error)

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

                        func (*FakeClusters) Watch

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

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

                          type FakeMachineClasses

                          type FakeMachineClasses struct {
                          	Fake *FakeClusterV1alpha1
                          	// contains filtered or unexported fields
                          }

                            FakeMachineClasses implements MachineClassInterface

                            func (*FakeMachineClasses) Create

                            func (c *FakeMachineClasses) Create(machineClass *v1alpha1.MachineClass) (result *v1alpha1.MachineClass, err error)

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

                              func (*FakeMachineClasses) Delete

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

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

                                func (*FakeMachineClasses) DeleteCollection

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

                                  DeleteCollection deletes a collection of objects.

                                  func (*FakeMachineClasses) Get

                                  func (c *FakeMachineClasses) Get(name string, options v1.GetOptions) (result *v1alpha1.MachineClass, err error)

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

                                    func (*FakeMachineClasses) List

                                    func (c *FakeMachineClasses) List(opts v1.ListOptions) (result *v1alpha1.MachineClassList, err error)

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

                                      func (*FakeMachineClasses) Patch

                                      func (c *FakeMachineClasses) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.MachineClass, err error)

                                        Patch applies the patch and returns the patched machineClass.

                                        func (*FakeMachineClasses) Update

                                        func (c *FakeMachineClasses) Update(machineClass *v1alpha1.MachineClass) (result *v1alpha1.MachineClass, err error)

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

                                          func (*FakeMachineClasses) Watch

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

                                            type FakeMachineDeployments

                                            type FakeMachineDeployments struct {
                                            	Fake *FakeClusterV1alpha1
                                            	// contains filtered or unexported fields
                                            }

                                              FakeMachineDeployments implements MachineDeploymentInterface

                                              func (*FakeMachineDeployments) Create

                                              func (c *FakeMachineDeployments) Create(machineDeployment *v1alpha1.MachineDeployment) (result *v1alpha1.MachineDeployment, err error)

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

                                                func (*FakeMachineDeployments) Delete

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

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

                                                  func (*FakeMachineDeployments) DeleteCollection

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

                                                    DeleteCollection deletes a collection of objects.

                                                    func (*FakeMachineDeployments) Get

                                                    func (c *FakeMachineDeployments) Get(name string, options v1.GetOptions) (result *v1alpha1.MachineDeployment, err error)

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

                                                      func (*FakeMachineDeployments) List

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

                                                        func (*FakeMachineDeployments) Patch

                                                        func (c *FakeMachineDeployments) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.MachineDeployment, err error)

                                                          Patch applies the patch and returns the patched machineDeployment.

                                                          func (*FakeMachineDeployments) Update

                                                          func (c *FakeMachineDeployments) Update(machineDeployment *v1alpha1.MachineDeployment) (result *v1alpha1.MachineDeployment, err error)

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

                                                            func (*FakeMachineDeployments) UpdateStatus

                                                            func (c *FakeMachineDeployments) UpdateStatus(machineDeployment *v1alpha1.MachineDeployment) (*v1alpha1.MachineDeployment, error)

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

                                                              func (*FakeMachineDeployments) Watch

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

                                                                type FakeMachineSets

                                                                type FakeMachineSets struct {
                                                                	Fake *FakeClusterV1alpha1
                                                                	// contains filtered or unexported fields
                                                                }

                                                                  FakeMachineSets implements MachineSetInterface

                                                                  func (*FakeMachineSets) Create

                                                                  func (c *FakeMachineSets) Create(machineSet *v1alpha1.MachineSet) (result *v1alpha1.MachineSet, err error)

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

                                                                    func (*FakeMachineSets) Delete

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

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

                                                                      func (*FakeMachineSets) DeleteCollection

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

                                                                        DeleteCollection deletes a collection of objects.

                                                                        func (*FakeMachineSets) Get

                                                                        func (c *FakeMachineSets) Get(name string, options v1.GetOptions) (result *v1alpha1.MachineSet, err error)

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

                                                                          func (*FakeMachineSets) List

                                                                          func (c *FakeMachineSets) List(opts v1.ListOptions) (result *v1alpha1.MachineSetList, err error)

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

                                                                            func (*FakeMachineSets) Patch

                                                                            func (c *FakeMachineSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.MachineSet, err error)

                                                                              Patch applies the patch and returns the patched machineSet.

                                                                              func (*FakeMachineSets) Update

                                                                              func (c *FakeMachineSets) Update(machineSet *v1alpha1.MachineSet) (result *v1alpha1.MachineSet, err error)

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

                                                                                func (*FakeMachineSets) UpdateStatus

                                                                                func (c *FakeMachineSets) UpdateStatus(machineSet *v1alpha1.MachineSet) (*v1alpha1.MachineSet, error)

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

                                                                                  func (*FakeMachineSets) Watch

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

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

                                                                                    type FakeMachines

                                                                                    type FakeMachines struct {
                                                                                    	Fake *FakeClusterV1alpha1
                                                                                    	// contains filtered or unexported fields
                                                                                    }

                                                                                      FakeMachines implements MachineInterface

                                                                                      func (*FakeMachines) Create

                                                                                      func (c *FakeMachines) Create(machine *v1alpha1.Machine) (result *v1alpha1.Machine, err error)

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

                                                                                        func (*FakeMachines) Delete

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

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

                                                                                          func (*FakeMachines) DeleteCollection

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

                                                                                            DeleteCollection deletes a collection of objects.

                                                                                            func (*FakeMachines) Get

                                                                                            func (c *FakeMachines) Get(name string, options v1.GetOptions) (result *v1alpha1.Machine, err error)

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

                                                                                              func (*FakeMachines) List

                                                                                              func (c *FakeMachines) List(opts v1.ListOptions) (result *v1alpha1.MachineList, err error)

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

                                                                                                func (*FakeMachines) Patch

                                                                                                func (c *FakeMachines) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Machine, err error)

                                                                                                  Patch applies the patch and returns the patched machine.

                                                                                                  func (*FakeMachines) Update

                                                                                                  func (c *FakeMachines) Update(machine *v1alpha1.Machine) (result *v1alpha1.Machine, err error)

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

                                                                                                    func (*FakeMachines) UpdateStatus

                                                                                                    func (c *FakeMachines) UpdateStatus(machine *v1alpha1.Machine) (*v1alpha1.Machine, error)

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

                                                                                                      func (*FakeMachines) Watch

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

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