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 FakeElasticsearches

    type FakeElasticsearches struct {
    	Fake *FakeKubedbV1alpha2
    	// contains filtered or unexported fields
    }

      FakeElasticsearches implements ElasticsearchInterface

      func (*FakeElasticsearches) Create

      func (c *FakeElasticsearches) Create(ctx context.Context, elasticsearch *v1alpha2.Elasticsearch, opts v1.CreateOptions) (result *v1alpha2.Elasticsearch, err error)

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

        func (*FakeElasticsearches) Delete

        func (c *FakeElasticsearches) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

          func (*FakeElasticsearches) DeleteCollection

          func (c *FakeElasticsearches) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

            DeleteCollection deletes a collection of objects.

            func (*FakeElasticsearches) Get

            func (c *FakeElasticsearches) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.Elasticsearch, err error)

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

              func (*FakeElasticsearches) List

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

                func (*FakeElasticsearches) Patch

                func (c *FakeElasticsearches) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.Elasticsearch, err error)

                  Patch applies the patch and returns the patched elasticsearch.

                  func (*FakeElasticsearches) Update

                  func (c *FakeElasticsearches) Update(ctx context.Context, elasticsearch *v1alpha2.Elasticsearch, opts v1.UpdateOptions) (result *v1alpha2.Elasticsearch, err error)

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

                    func (*FakeElasticsearches) UpdateStatus

                    func (c *FakeElasticsearches) UpdateStatus(ctx context.Context, elasticsearch *v1alpha2.Elasticsearch, opts v1.UpdateOptions) (*v1alpha2.Elasticsearch, error)

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

                      func (*FakeElasticsearches) Watch

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

                        type FakeEtcds

                        type FakeEtcds struct {
                        	Fake *FakeKubedbV1alpha2
                        	// contains filtered or unexported fields
                        }

                          FakeEtcds implements EtcdInterface

                          func (*FakeEtcds) Create

                          func (c *FakeEtcds) Create(ctx context.Context, etcd *v1alpha2.Etcd, opts v1.CreateOptions) (result *v1alpha2.Etcd, err error)

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

                            func (*FakeEtcds) Delete

                            func (c *FakeEtcds) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                              func (*FakeEtcds) DeleteCollection

                              func (c *FakeEtcds) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                DeleteCollection deletes a collection of objects.

                                func (*FakeEtcds) Get

                                func (c *FakeEtcds) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.Etcd, err error)

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

                                  func (*FakeEtcds) List

                                  func (c *FakeEtcds) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.EtcdList, err error)

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

                                    func (*FakeEtcds) Patch

                                    func (c *FakeEtcds) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.Etcd, err error)

                                      Patch applies the patch and returns the patched etcd.

                                      func (*FakeEtcds) Update

                                      func (c *FakeEtcds) Update(ctx context.Context, etcd *v1alpha2.Etcd, opts v1.UpdateOptions) (result *v1alpha2.Etcd, err error)

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

                                        func (*FakeEtcds) UpdateStatus

                                        func (c *FakeEtcds) UpdateStatus(ctx context.Context, etcd *v1alpha2.Etcd, opts v1.UpdateOptions) (*v1alpha2.Etcd, error)

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

                                          func (*FakeEtcds) Watch

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

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

                                            type FakeKubedbV1alpha2

                                            type FakeKubedbV1alpha2 struct {
                                            	*testing.Fake
                                            }

                                            func (*FakeKubedbV1alpha2) Elasticsearches

                                            func (c *FakeKubedbV1alpha2) Elasticsearches(namespace string) v1alpha2.ElasticsearchInterface

                                            func (*FakeKubedbV1alpha2) Etcds

                                            func (c *FakeKubedbV1alpha2) Etcds(namespace string) v1alpha2.EtcdInterface

                                            func (*FakeKubedbV1alpha2) MariaDBs

                                            func (c *FakeKubedbV1alpha2) MariaDBs(namespace string) v1alpha2.MariaDBInterface

                                            func (*FakeKubedbV1alpha2) Memcacheds

                                            func (c *FakeKubedbV1alpha2) Memcacheds(namespace string) v1alpha2.MemcachedInterface

                                            func (*FakeKubedbV1alpha2) MongoDBs

                                            func (c *FakeKubedbV1alpha2) MongoDBs(namespace string) v1alpha2.MongoDBInterface

                                            func (*FakeKubedbV1alpha2) MySQLs

                                            func (c *FakeKubedbV1alpha2) MySQLs(namespace string) v1alpha2.MySQLInterface

                                            func (*FakeKubedbV1alpha2) PerconaXtraDBs

                                            func (c *FakeKubedbV1alpha2) PerconaXtraDBs(namespace string) v1alpha2.PerconaXtraDBInterface

                                            func (*FakeKubedbV1alpha2) PgBouncers

                                            func (c *FakeKubedbV1alpha2) PgBouncers(namespace string) v1alpha2.PgBouncerInterface

                                            func (*FakeKubedbV1alpha2) Postgreses

                                            func (c *FakeKubedbV1alpha2) Postgreses(namespace string) v1alpha2.PostgresInterface

                                            func (*FakeKubedbV1alpha2) ProxySQLs

                                            func (c *FakeKubedbV1alpha2) ProxySQLs(namespace string) v1alpha2.ProxySQLInterface

                                            func (*FakeKubedbV1alpha2) RESTClient

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

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

                                              func (*FakeKubedbV1alpha2) Redises

                                              func (c *FakeKubedbV1alpha2) Redises(namespace string) v1alpha2.RedisInterface

                                              type FakeMariaDBs

                                              type FakeMariaDBs struct {
                                              	Fake *FakeKubedbV1alpha2
                                              	// contains filtered or unexported fields
                                              }

                                                FakeMariaDBs implements MariaDBInterface

                                                func (*FakeMariaDBs) Create

                                                func (c *FakeMariaDBs) Create(ctx context.Context, mariaDB *v1alpha2.MariaDB, opts v1.CreateOptions) (result *v1alpha2.MariaDB, err error)

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

                                                  func (*FakeMariaDBs) Delete

                                                  func (c *FakeMariaDBs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                    func (*FakeMariaDBs) DeleteCollection

                                                    func (c *FakeMariaDBs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                      DeleteCollection deletes a collection of objects.

                                                      func (*FakeMariaDBs) Get

                                                      func (c *FakeMariaDBs) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.MariaDB, err error)

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

                                                        func (*FakeMariaDBs) List

                                                        func (c *FakeMariaDBs) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.MariaDBList, err error)

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

                                                          func (*FakeMariaDBs) Patch

                                                          func (c *FakeMariaDBs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.MariaDB, err error)

                                                            Patch applies the patch and returns the patched mariaDB.

                                                            func (*FakeMariaDBs) Update

                                                            func (c *FakeMariaDBs) Update(ctx context.Context, mariaDB *v1alpha2.MariaDB, opts v1.UpdateOptions) (result *v1alpha2.MariaDB, err error)

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

                                                              func (*FakeMariaDBs) UpdateStatus

                                                              func (c *FakeMariaDBs) UpdateStatus(ctx context.Context, mariaDB *v1alpha2.MariaDB, opts v1.UpdateOptions) (*v1alpha2.MariaDB, error)

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

                                                                func (*FakeMariaDBs) Watch

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

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

                                                                  type FakeMemcacheds

                                                                  type FakeMemcacheds struct {
                                                                  	Fake *FakeKubedbV1alpha2
                                                                  	// contains filtered or unexported fields
                                                                  }

                                                                    FakeMemcacheds implements MemcachedInterface

                                                                    func (*FakeMemcacheds) Create

                                                                    func (c *FakeMemcacheds) Create(ctx context.Context, memcached *v1alpha2.Memcached, opts v1.CreateOptions) (result *v1alpha2.Memcached, err error)

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

                                                                      func (*FakeMemcacheds) Delete

                                                                      func (c *FakeMemcacheds) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                                        func (*FakeMemcacheds) DeleteCollection

                                                                        func (c *FakeMemcacheds) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                                          DeleteCollection deletes a collection of objects.

                                                                          func (*FakeMemcacheds) Get

                                                                          func (c *FakeMemcacheds) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.Memcached, err error)

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

                                                                            func (*FakeMemcacheds) List

                                                                            func (c *FakeMemcacheds) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.MemcachedList, err error)

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

                                                                              func (*FakeMemcacheds) Patch

                                                                              func (c *FakeMemcacheds) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.Memcached, err error)

                                                                                Patch applies the patch and returns the patched memcached.

                                                                                func (*FakeMemcacheds) Update

                                                                                func (c *FakeMemcacheds) Update(ctx context.Context, memcached *v1alpha2.Memcached, opts v1.UpdateOptions) (result *v1alpha2.Memcached, err error)

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

                                                                                  func (*FakeMemcacheds) UpdateStatus

                                                                                  func (c *FakeMemcacheds) UpdateStatus(ctx context.Context, memcached *v1alpha2.Memcached, opts v1.UpdateOptions) (*v1alpha2.Memcached, error)

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

                                                                                    func (*FakeMemcacheds) Watch

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

                                                                                      type FakeMongoDBs

                                                                                      type FakeMongoDBs struct {
                                                                                      	Fake *FakeKubedbV1alpha2
                                                                                      	// contains filtered or unexported fields
                                                                                      }

                                                                                        FakeMongoDBs implements MongoDBInterface

                                                                                        func (*FakeMongoDBs) Create

                                                                                        func (c *FakeMongoDBs) Create(ctx context.Context, mongoDB *v1alpha2.MongoDB, opts v1.CreateOptions) (result *v1alpha2.MongoDB, err error)

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

                                                                                          func (*FakeMongoDBs) Delete

                                                                                          func (c *FakeMongoDBs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                                                            func (*FakeMongoDBs) DeleteCollection

                                                                                            func (c *FakeMongoDBs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                                                              DeleteCollection deletes a collection of objects.

                                                                                              func (*FakeMongoDBs) Get

                                                                                              func (c *FakeMongoDBs) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.MongoDB, err error)

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

                                                                                                func (*FakeMongoDBs) List

                                                                                                func (c *FakeMongoDBs) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.MongoDBList, err error)

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

                                                                                                  func (*FakeMongoDBs) Patch

                                                                                                  func (c *FakeMongoDBs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.MongoDB, err error)

                                                                                                    Patch applies the patch and returns the patched mongoDB.

                                                                                                    func (*FakeMongoDBs) Update

                                                                                                    func (c *FakeMongoDBs) Update(ctx context.Context, mongoDB *v1alpha2.MongoDB, opts v1.UpdateOptions) (result *v1alpha2.MongoDB, err error)

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

                                                                                                      func (*FakeMongoDBs) UpdateStatus

                                                                                                      func (c *FakeMongoDBs) UpdateStatus(ctx context.Context, mongoDB *v1alpha2.MongoDB, opts v1.UpdateOptions) (*v1alpha2.MongoDB, error)

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

                                                                                                        func (*FakeMongoDBs) Watch

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

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

                                                                                                          type FakeMySQLs

                                                                                                          type FakeMySQLs struct {
                                                                                                          	Fake *FakeKubedbV1alpha2
                                                                                                          	// contains filtered or unexported fields
                                                                                                          }

                                                                                                            FakeMySQLs implements MySQLInterface

                                                                                                            func (*FakeMySQLs) Create

                                                                                                            func (c *FakeMySQLs) Create(ctx context.Context, mySQL *v1alpha2.MySQL, opts v1.CreateOptions) (result *v1alpha2.MySQL, err error)

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

                                                                                                              func (*FakeMySQLs) Delete

                                                                                                              func (c *FakeMySQLs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                                                                                func (*FakeMySQLs) DeleteCollection

                                                                                                                func (c *FakeMySQLs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                                                                                  DeleteCollection deletes a collection of objects.

                                                                                                                  func (*FakeMySQLs) Get

                                                                                                                  func (c *FakeMySQLs) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.MySQL, err error)

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

                                                                                                                    func (*FakeMySQLs) List

                                                                                                                    func (c *FakeMySQLs) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.MySQLList, err error)

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

                                                                                                                      func (*FakeMySQLs) Patch

                                                                                                                      func (c *FakeMySQLs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.MySQL, err error)

                                                                                                                        Patch applies the patch and returns the patched mySQL.

                                                                                                                        func (*FakeMySQLs) Update

                                                                                                                        func (c *FakeMySQLs) Update(ctx context.Context, mySQL *v1alpha2.MySQL, opts v1.UpdateOptions) (result *v1alpha2.MySQL, err error)

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

                                                                                                                          func (*FakeMySQLs) UpdateStatus

                                                                                                                          func (c *FakeMySQLs) UpdateStatus(ctx context.Context, mySQL *v1alpha2.MySQL, opts v1.UpdateOptions) (*v1alpha2.MySQL, error)

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

                                                                                                                            func (*FakeMySQLs) Watch

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

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

                                                                                                                              type FakePerconaXtraDBs

                                                                                                                              type FakePerconaXtraDBs struct {
                                                                                                                              	Fake *FakeKubedbV1alpha2
                                                                                                                              	// contains filtered or unexported fields
                                                                                                                              }

                                                                                                                                FakePerconaXtraDBs implements PerconaXtraDBInterface

                                                                                                                                func (*FakePerconaXtraDBs) Create

                                                                                                                                func (c *FakePerconaXtraDBs) Create(ctx context.Context, perconaXtraDB *v1alpha2.PerconaXtraDB, opts v1.CreateOptions) (result *v1alpha2.PerconaXtraDB, err error)

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

                                                                                                                                  func (*FakePerconaXtraDBs) Delete

                                                                                                                                  func (c *FakePerconaXtraDBs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                                                                                                    func (*FakePerconaXtraDBs) DeleteCollection

                                                                                                                                    func (c *FakePerconaXtraDBs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                                                                                                      DeleteCollection deletes a collection of objects.

                                                                                                                                      func (*FakePerconaXtraDBs) Get

                                                                                                                                      func (c *FakePerconaXtraDBs) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.PerconaXtraDB, err error)

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

                                                                                                                                        func (*FakePerconaXtraDBs) List

                                                                                                                                        func (c *FakePerconaXtraDBs) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.PerconaXtraDBList, err error)

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

                                                                                                                                          func (*FakePerconaXtraDBs) Patch

                                                                                                                                          func (c *FakePerconaXtraDBs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.PerconaXtraDB, err error)

                                                                                                                                            Patch applies the patch and returns the patched perconaXtraDB.

                                                                                                                                            func (*FakePerconaXtraDBs) Update

                                                                                                                                            func (c *FakePerconaXtraDBs) Update(ctx context.Context, perconaXtraDB *v1alpha2.PerconaXtraDB, opts v1.UpdateOptions) (result *v1alpha2.PerconaXtraDB, err error)

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

                                                                                                                                              func (*FakePerconaXtraDBs) UpdateStatus

                                                                                                                                              func (c *FakePerconaXtraDBs) UpdateStatus(ctx context.Context, perconaXtraDB *v1alpha2.PerconaXtraDB, opts v1.UpdateOptions) (*v1alpha2.PerconaXtraDB, error)

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

                                                                                                                                                func (*FakePerconaXtraDBs) Watch

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

                                                                                                                                                  type FakePgBouncers

                                                                                                                                                  type FakePgBouncers struct {
                                                                                                                                                  	Fake *FakeKubedbV1alpha2
                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                  }

                                                                                                                                                    FakePgBouncers implements PgBouncerInterface

                                                                                                                                                    func (*FakePgBouncers) Create

                                                                                                                                                    func (c *FakePgBouncers) Create(ctx context.Context, pgBouncer *v1alpha2.PgBouncer, opts v1.CreateOptions) (result *v1alpha2.PgBouncer, err error)

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

                                                                                                                                                      func (*FakePgBouncers) Delete

                                                                                                                                                      func (c *FakePgBouncers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                                                                                                                        func (*FakePgBouncers) DeleteCollection

                                                                                                                                                        func (c *FakePgBouncers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                                                                                                                          DeleteCollection deletes a collection of objects.

                                                                                                                                                          func (*FakePgBouncers) Get

                                                                                                                                                          func (c *FakePgBouncers) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.PgBouncer, err error)

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

                                                                                                                                                            func (*FakePgBouncers) List

                                                                                                                                                            func (c *FakePgBouncers) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.PgBouncerList, err error)

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

                                                                                                                                                              func (*FakePgBouncers) Patch

                                                                                                                                                              func (c *FakePgBouncers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.PgBouncer, err error)

                                                                                                                                                                Patch applies the patch and returns the patched pgBouncer.

                                                                                                                                                                func (*FakePgBouncers) Update

                                                                                                                                                                func (c *FakePgBouncers) Update(ctx context.Context, pgBouncer *v1alpha2.PgBouncer, opts v1.UpdateOptions) (result *v1alpha2.PgBouncer, err error)

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

                                                                                                                                                                  func (*FakePgBouncers) UpdateStatus

                                                                                                                                                                  func (c *FakePgBouncers) UpdateStatus(ctx context.Context, pgBouncer *v1alpha2.PgBouncer, opts v1.UpdateOptions) (*v1alpha2.PgBouncer, error)

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

                                                                                                                                                                    func (*FakePgBouncers) Watch

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

                                                                                                                                                                      type FakePostgreses

                                                                                                                                                                      type FakePostgreses struct {
                                                                                                                                                                      	Fake *FakeKubedbV1alpha2
                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                      }

                                                                                                                                                                        FakePostgreses implements PostgresInterface

                                                                                                                                                                        func (*FakePostgreses) Create

                                                                                                                                                                        func (c *FakePostgreses) Create(ctx context.Context, postgres *v1alpha2.Postgres, opts v1.CreateOptions) (result *v1alpha2.Postgres, err error)

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

                                                                                                                                                                          func (*FakePostgreses) Delete

                                                                                                                                                                          func (c *FakePostgreses) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                                                                                                                                            func (*FakePostgreses) DeleteCollection

                                                                                                                                                                            func (c *FakePostgreses) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                                                                                                                                              DeleteCollection deletes a collection of objects.

                                                                                                                                                                              func (*FakePostgreses) Get

                                                                                                                                                                              func (c *FakePostgreses) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.Postgres, err error)

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

                                                                                                                                                                                func (*FakePostgreses) List

                                                                                                                                                                                func (c *FakePostgreses) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.PostgresList, err error)

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

                                                                                                                                                                                  func (*FakePostgreses) Patch

                                                                                                                                                                                  func (c *FakePostgreses) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.Postgres, err error)

                                                                                                                                                                                    Patch applies the patch and returns the patched postgres.

                                                                                                                                                                                    func (*FakePostgreses) Update

                                                                                                                                                                                    func (c *FakePostgreses) Update(ctx context.Context, postgres *v1alpha2.Postgres, opts v1.UpdateOptions) (result *v1alpha2.Postgres, err error)

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

                                                                                                                                                                                      func (*FakePostgreses) UpdateStatus

                                                                                                                                                                                      func (c *FakePostgreses) UpdateStatus(ctx context.Context, postgres *v1alpha2.Postgres, opts v1.UpdateOptions) (*v1alpha2.Postgres, error)

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

                                                                                                                                                                                        func (*FakePostgreses) Watch

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

                                                                                                                                                                                          type FakeProxySQLs

                                                                                                                                                                                          type FakeProxySQLs struct {
                                                                                                                                                                                          	Fake *FakeKubedbV1alpha2
                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                          }

                                                                                                                                                                                            FakeProxySQLs implements ProxySQLInterface

                                                                                                                                                                                            func (*FakeProxySQLs) Create

                                                                                                                                                                                            func (c *FakeProxySQLs) Create(ctx context.Context, proxySQL *v1alpha2.ProxySQL, opts v1.CreateOptions) (result *v1alpha2.ProxySQL, err error)

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

                                                                                                                                                                                              func (*FakeProxySQLs) Delete

                                                                                                                                                                                              func (c *FakeProxySQLs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                                                                                                                                                                func (*FakeProxySQLs) DeleteCollection

                                                                                                                                                                                                func (c *FakeProxySQLs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                                                                                                                                                                  DeleteCollection deletes a collection of objects.

                                                                                                                                                                                                  func (*FakeProxySQLs) Get

                                                                                                                                                                                                  func (c *FakeProxySQLs) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.ProxySQL, err error)

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

                                                                                                                                                                                                    func (*FakeProxySQLs) List

                                                                                                                                                                                                    func (c *FakeProxySQLs) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.ProxySQLList, err error)

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

                                                                                                                                                                                                      func (*FakeProxySQLs) Patch

                                                                                                                                                                                                      func (c *FakeProxySQLs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.ProxySQL, err error)

                                                                                                                                                                                                        Patch applies the patch and returns the patched proxySQL.

                                                                                                                                                                                                        func (*FakeProxySQLs) Update

                                                                                                                                                                                                        func (c *FakeProxySQLs) Update(ctx context.Context, proxySQL *v1alpha2.ProxySQL, opts v1.UpdateOptions) (result *v1alpha2.ProxySQL, err error)

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

                                                                                                                                                                                                          func (*FakeProxySQLs) UpdateStatus

                                                                                                                                                                                                          func (c *FakeProxySQLs) UpdateStatus(ctx context.Context, proxySQL *v1alpha2.ProxySQL, opts v1.UpdateOptions) (*v1alpha2.ProxySQL, error)

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

                                                                                                                                                                                                            func (*FakeProxySQLs) Watch

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

                                                                                                                                                                                                              type FakeRedises

                                                                                                                                                                                                              type FakeRedises struct {
                                                                                                                                                                                                              	Fake *FakeKubedbV1alpha2
                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                              }

                                                                                                                                                                                                                FakeRedises implements RedisInterface

                                                                                                                                                                                                                func (*FakeRedises) Create

                                                                                                                                                                                                                func (c *FakeRedises) Create(ctx context.Context, redis *v1alpha2.Redis, opts v1.CreateOptions) (result *v1alpha2.Redis, err error)

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

                                                                                                                                                                                                                  func (*FakeRedises) Delete

                                                                                                                                                                                                                  func (c *FakeRedises) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error

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

                                                                                                                                                                                                                    func (*FakeRedises) DeleteCollection

                                                                                                                                                                                                                    func (c *FakeRedises) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error

                                                                                                                                                                                                                      DeleteCollection deletes a collection of objects.

                                                                                                                                                                                                                      func (*FakeRedises) Get

                                                                                                                                                                                                                      func (c *FakeRedises) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha2.Redis, err error)

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

                                                                                                                                                                                                                        func (*FakeRedises) List

                                                                                                                                                                                                                        func (c *FakeRedises) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha2.RedisList, err error)

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

                                                                                                                                                                                                                          func (*FakeRedises) Patch

                                                                                                                                                                                                                          func (c *FakeRedises) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha2.Redis, err error)

                                                                                                                                                                                                                            Patch applies the patch and returns the patched redis.

                                                                                                                                                                                                                            func (*FakeRedises) Update

                                                                                                                                                                                                                            func (c *FakeRedises) Update(ctx context.Context, redis *v1alpha2.Redis, opts v1.UpdateOptions) (result *v1alpha2.Redis, err error)

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

                                                                                                                                                                                                                              func (*FakeRedises) UpdateStatus

                                                                                                                                                                                                                              func (c *FakeRedises) UpdateStatus(ctx context.Context, redis *v1alpha2.Redis, opts v1.UpdateOptions) (*v1alpha2.Redis, error)

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

                                                                                                                                                                                                                                func (*FakeRedises) Watch

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

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