diff --git a/pkg/eventing/sources/v1alpha1/client.go b/pkg/eventing/sources/v1alpha1/client.go index fb972e3b4..3d1b0dfcf 100644 --- a/pkg/eventing/sources/v1alpha1/client.go +++ b/pkg/eventing/sources/v1alpha1/client.go @@ -18,6 +18,13 @@ import ( client_v1alpha1 "knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1" ) +// KnSourcesClient to Eventing Sources. All methods are relative to the +// namespace specified during construction +type KnSourcesClient interface { + // Namespace in which this client is operating for + Namespace() string +} + // knSourcesClient is a combination of Sources client interface and namespace // Temporarily help to add sources dependencies // May be changed when adding real sources features @@ -25,3 +32,16 @@ type knSourcesClient struct { client client_v1alpha1.SourcesV1alpha1Interface namespace string } + +// NewKnSourcesClient is to invoke Eventing Sources Client API to create object +func NewKnSourcesClient(client client_v1alpha1.SourcesV1alpha1Interface, namespace string) KnSourcesClient { + return &knSourcesClient{ + namespace: namespace, + client: client, + } +} + +// Return the client's namespace +func (c *knSourcesClient) Namespace() string { + return c.namespace +} diff --git a/pkg/kn/commands/testing_helper.go b/pkg/kn/commands/testing_helper.go index 470e35392..d6a78fb4a 100644 --- a/pkg/kn/commands/testing_helper.go +++ b/pkg/kn/commands/testing_helper.go @@ -29,6 +29,9 @@ import ( "knative.dev/client/pkg/serving/v1alpha1" "knative.dev/serving/pkg/client/clientset/versioned/typed/serving/v1alpha1/fake" + + sources_client "knative.dev/client/pkg/eventing/sources/v1alpha1" + sources_fake "knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake" ) const FakeNamespace = "current" @@ -54,6 +57,19 @@ func CreateTestKnCommand(cmd *cobra.Command, knParams *KnParams) (*cobra.Command return knCommand, fakeServing, buf } +// CreateSourcesTestKnCommand helper for creating test commands +func CreateSourcesTestKnCommand(cmd *cobra.Command, knParams *KnParams) (*cobra.Command, *sources_fake.FakeSourcesV1alpha1, *bytes.Buffer) { + buf := new(bytes.Buffer) + fakeEventing := &sources_fake.FakeSourcesV1alpha1{&client_testing.Fake{}} + knParams.Output = buf + knParams.NewSourcesClient = func(namespace string) (sources_client.KnSourcesClient, error) { + return sources_client.NewKnSourcesClient(fakeEventing, FakeNamespace), nil + } + knParams.fixedCurrentNamespace = FakeNamespace + knCommand := NewKnTestCommand(cmd, knParams) + return knCommand, fakeEventing, buf +} + // CaptureStdout collects the current content of os.Stdout func CaptureStdout(t *testing.T) { oldStdout = os.Stdout diff --git a/pkg/kn/commands/testing_helper_test.go b/pkg/kn/commands/testing_helper_test.go index 1c856908f..822eb218f 100644 --- a/pkg/kn/commands/testing_helper_test.go +++ b/pkg/kn/commands/testing_helper_test.go @@ -21,6 +21,7 @@ import ( "github.com/spf13/cobra" "gotest.tools/assert" + sources_fake "knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake" "knative.dev/serving/pkg/client/clientset/versioned/typed/serving/v1alpha1/fake" ) @@ -54,3 +55,34 @@ func TestCreateTestKnCommand(t *testing.T) { assert.Assert(t, knCmd.SilenceErrors == true) }) } + +func TestCreateSourcesTestKnCommand(t *testing.T) { + var ( + knCmd *cobra.Command + serving *sources_fake.FakeSourcesV1alpha1 + buffer *bytes.Buffer + ) + + setup := func(t *testing.T) { + knParams := &KnParams{} + knCmd, serving, buffer = CreateSourcesTestKnCommand(&cobra.Command{Use: "fake"}, knParams) + assert.Assert(t, knCmd != nil) + assert.Assert(t, len(knCmd.Commands()) == 1) + assert.Assert(t, knCmd.Commands()[0].Use == "fake") + assert.Assert(t, serving != nil) + assert.Assert(t, buffer != nil) + } + + t.Run("creates a new kn cobra.Command", func(t *testing.T) { + setup(t) + + assert.Assert(t, knCmd != nil) + assert.Assert(t, knCmd.Use == "kn") + assert.Assert(t, knCmd.Short == "Knative client") + assert.Assert(t, strings.Contains(knCmd.Long, "Manage your Knative building blocks:")) + assert.Assert(t, knCmd.RunE == nil) + assert.Assert(t, knCmd.DisableAutoGenTag == true) + assert.Assert(t, knCmd.SilenceUsage == true) + assert.Assert(t, knCmd.SilenceErrors == true) + }) +} diff --git a/pkg/kn/commands/types.go b/pkg/kn/commands/types.go index 9491d911f..f0b290cbf 100644 --- a/pkg/kn/commands/types.go +++ b/pkg/kn/commands/types.go @@ -21,8 +21,10 @@ import ( "path/filepath" "k8s.io/client-go/tools/clientcmd" + sources_kn_v1alpha1 "knative.dev/client/pkg/eventing/sources/v1alpha1" serving_kn_v1alpha1 "knative.dev/client/pkg/serving/v1alpha1" "knative.dev/client/pkg/util" + eventing_sources "knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1" serving_v1alpha1_client "knative.dev/serving/pkg/client/clientset/versioned/typed/serving/v1alpha1" ) @@ -40,10 +42,11 @@ type Config struct { // Parameters for creating commands. Useful for inserting mocks for testing. type KnParams struct { - Output io.Writer - KubeCfgPath string - ClientConfig clientcmd.ClientConfig - NewClient func(namespace string) (serving_kn_v1alpha1.KnServingClient, error) + Output io.Writer + KubeCfgPath string + ClientConfig clientcmd.ClientConfig + NewClient func(namespace string) (serving_kn_v1alpha1.KnServingClient, error) + NewSourcesClient func(namespace string) (sources_kn_v1alpha1.KnSourcesClient, error) // General global options LogHTTP bool @@ -56,6 +59,9 @@ func (params *KnParams) Initialize() { if params.NewClient == nil { params.NewClient = params.newClient } + if params.NewSourcesClient == nil { + params.NewSourcesClient = params.newSourcesClient + } } func (params *KnParams) newClient(namespace string) (serving_kn_v1alpha1.KnServingClient, error) { @@ -66,6 +72,29 @@ func (params *KnParams) newClient(namespace string) (serving_kn_v1alpha1.KnServi return serving_kn_v1alpha1.NewKnServingClient(client, namespace), nil } +func (params *KnParams) newSourcesClient(namespace string) (sources_kn_v1alpha1.KnSourcesClient, error) { + var err error + + if params.ClientConfig == nil { + params.ClientConfig, err = params.GetClientConfig() + if err != nil { + return nil, err + } + } + + clientConfig, err := params.ClientConfig.ClientConfig() + if err != nil { + return nil, err + } + if params.LogHTTP { + // TODO: When we update to the newer version of client-go, replace with + // config.Wrap() for future compat. + clientConfig.WrapTransport = util.NewLoggingTransport + } + client, _ := eventing_sources.NewForConfig(clientConfig) + return sources_kn_v1alpha1.NewKnSourcesClient(client, namespace), nil +} + // GetConfig returns Serving Client func (params *KnParams) GetConfig() (serving_v1alpha1_client.ServingV1alpha1Interface, error) { var err error diff --git a/pkg/kn/commands/types_test.go b/pkg/kn/commands/types_test.go index e56e2e140..5714cbf51 100644 --- a/pkg/kn/commands/types_test.go +++ b/pkg/kn/commands/types_test.go @@ -141,3 +141,53 @@ func TestGetClientConfig(t *testing.T) { } } } + +func TestNewSourcesClient(t *testing.T) { + basic, err := clientcmd.NewClientConfigFromBytes([]byte(BASIC_KUBECONFIG)) + namespace := "test" + if err != nil { + t.Error(err) + } + for i, tc := range []getConfigTestCase{ + { + clientcmd.NewDefaultClientConfig(clientcmdapi.Config{}, &clientcmd.ConfigOverrides{}), + "no configuration has been provided", + false, + }, + { + basic, + "", + false, + }, + { // Test that the cast to wrap the http client in a logger works + basic, + "", + true, + }, + } { + p := &KnParams{ + ClientConfig: tc.clientConfig, + LogHTTP: tc.logHttp, + } + + sourcesClient, err := p.newSourcesClient(namespace) + + switch len(tc.expectedErrString) { + case 0: + if err != nil { + t.Errorf("%d: unexpected error: %s", i, err.Error()) + } + default: + if err == nil { + t.Errorf("%d: wrong error detected: %s (expected) != %s (actual)", i, tc.expectedErrString, err) + } + if !strings.Contains(err.Error(), tc.expectedErrString) { + t.Errorf("%d: wrong error detected: %s (expected) != %s (actual)", i, tc.expectedErrString, err.Error()) + } + } + + if sourcesClient != nil { + assert.Assert(t, sourcesClient.Namespace() == namespace) + } + } +} diff --git a/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/doc.go b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/doc.go new file mode 100644 index 000000000..a00e5d7b2 --- /dev/null +++ b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/doc.go @@ -0,0 +1,20 @@ +/* +Copyright 2019 The Knative Authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +// Package fake has the automatically generated clients. +package fake diff --git a/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_apiserversource.go b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_apiserversource.go new file mode 100644 index 000000000..6d30ebe9b --- /dev/null +++ b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_apiserversource.go @@ -0,0 +1,140 @@ +/* +Copyright 2019 The Knative Authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" + v1alpha1 "knative.dev/eventing/pkg/apis/sources/v1alpha1" +) + +// FakeApiServerSources implements ApiServerSourceInterface +type FakeApiServerSources struct { + Fake *FakeSourcesV1alpha1 + ns string +} + +var apiserversourcesResource = schema.GroupVersionResource{Group: "sources.eventing.knative.dev", Version: "v1alpha1", Resource: "apiserversources"} + +var apiserversourcesKind = schema.GroupVersionKind{Group: "sources.eventing.knative.dev", Version: "v1alpha1", Kind: "ApiServerSource"} + +// Get takes name of the apiServerSource, and returns the corresponding apiServerSource object, and an error if there is any. +func (c *FakeApiServerSources) Get(name string, options v1.GetOptions) (result *v1alpha1.ApiServerSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(apiserversourcesResource, c.ns, name), &v1alpha1.ApiServerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ApiServerSource), err +} + +// List takes label and field selectors, and returns the list of ApiServerSources that match those selectors. +func (c *FakeApiServerSources) List(opts v1.ListOptions) (result *v1alpha1.ApiServerSourceList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(apiserversourcesResource, apiserversourcesKind, c.ns, opts), &v1alpha1.ApiServerSourceList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &v1alpha1.ApiServerSourceList{ListMeta: obj.(*v1alpha1.ApiServerSourceList).ListMeta} + for _, item := range obj.(*v1alpha1.ApiServerSourceList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested apiServerSources. +func (c *FakeApiServerSources) Watch(opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(apiserversourcesResource, c.ns, opts)) + +} + +// Create takes the representation of a apiServerSource and creates it. Returns the server's representation of the apiServerSource, and an error, if there is any. +func (c *FakeApiServerSources) Create(apiServerSource *v1alpha1.ApiServerSource) (result *v1alpha1.ApiServerSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(apiserversourcesResource, c.ns, apiServerSource), &v1alpha1.ApiServerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ApiServerSource), err +} + +// Update takes the representation of a apiServerSource and updates it. Returns the server's representation of the apiServerSource, and an error, if there is any. +func (c *FakeApiServerSources) Update(apiServerSource *v1alpha1.ApiServerSource) (result *v1alpha1.ApiServerSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(apiserversourcesResource, c.ns, apiServerSource), &v1alpha1.ApiServerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ApiServerSource), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeApiServerSources) UpdateStatus(apiServerSource *v1alpha1.ApiServerSource) (*v1alpha1.ApiServerSource, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(apiserversourcesResource, "status", c.ns, apiServerSource), &v1alpha1.ApiServerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ApiServerSource), err +} + +// Delete takes name of the apiServerSource and deletes it. Returns an error if one occurs. +func (c *FakeApiServerSources) Delete(name string, options *v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteAction(apiserversourcesResource, c.ns, name), &v1alpha1.ApiServerSource{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeApiServerSources) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(apiserversourcesResource, c.ns, listOptions) + + _, err := c.Fake.Invokes(action, &v1alpha1.ApiServerSourceList{}) + return err +} + +// Patch applies the patch and returns the patched apiServerSource. +func (c *FakeApiServerSources) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.ApiServerSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(apiserversourcesResource, c.ns, name, pt, data, subresources...), &v1alpha1.ApiServerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ApiServerSource), err +} diff --git a/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_containersource.go b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_containersource.go new file mode 100644 index 000000000..99c100fa2 --- /dev/null +++ b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_containersource.go @@ -0,0 +1,140 @@ +/* +Copyright 2019 The Knative Authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" + v1alpha1 "knative.dev/eventing/pkg/apis/sources/v1alpha1" +) + +// FakeContainerSources implements ContainerSourceInterface +type FakeContainerSources struct { + Fake *FakeSourcesV1alpha1 + ns string +} + +var containersourcesResource = schema.GroupVersionResource{Group: "sources.eventing.knative.dev", Version: "v1alpha1", Resource: "containersources"} + +var containersourcesKind = schema.GroupVersionKind{Group: "sources.eventing.knative.dev", Version: "v1alpha1", Kind: "ContainerSource"} + +// Get takes name of the containerSource, and returns the corresponding containerSource object, and an error if there is any. +func (c *FakeContainerSources) Get(name string, options v1.GetOptions) (result *v1alpha1.ContainerSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(containersourcesResource, c.ns, name), &v1alpha1.ContainerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ContainerSource), err +} + +// List takes label and field selectors, and returns the list of ContainerSources that match those selectors. +func (c *FakeContainerSources) List(opts v1.ListOptions) (result *v1alpha1.ContainerSourceList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(containersourcesResource, containersourcesKind, c.ns, opts), &v1alpha1.ContainerSourceList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &v1alpha1.ContainerSourceList{ListMeta: obj.(*v1alpha1.ContainerSourceList).ListMeta} + for _, item := range obj.(*v1alpha1.ContainerSourceList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested containerSources. +func (c *FakeContainerSources) Watch(opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(containersourcesResource, c.ns, opts)) + +} + +// Create takes the representation of a containerSource and creates it. Returns the server's representation of the containerSource, and an error, if there is any. +func (c *FakeContainerSources) Create(containerSource *v1alpha1.ContainerSource) (result *v1alpha1.ContainerSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(containersourcesResource, c.ns, containerSource), &v1alpha1.ContainerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ContainerSource), err +} + +// Update takes the representation of a containerSource and updates it. Returns the server's representation of the containerSource, and an error, if there is any. +func (c *FakeContainerSources) Update(containerSource *v1alpha1.ContainerSource) (result *v1alpha1.ContainerSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(containersourcesResource, c.ns, containerSource), &v1alpha1.ContainerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ContainerSource), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeContainerSources) UpdateStatus(containerSource *v1alpha1.ContainerSource) (*v1alpha1.ContainerSource, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(containersourcesResource, "status", c.ns, containerSource), &v1alpha1.ContainerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ContainerSource), err +} + +// Delete takes name of the containerSource and deletes it. Returns an error if one occurs. +func (c *FakeContainerSources) Delete(name string, options *v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteAction(containersourcesResource, c.ns, name), &v1alpha1.ContainerSource{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeContainerSources) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(containersourcesResource, c.ns, listOptions) + + _, err := c.Fake.Invokes(action, &v1alpha1.ContainerSourceList{}) + return err +} + +// Patch applies the patch and returns the patched containerSource. +func (c *FakeContainerSources) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.ContainerSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(containersourcesResource, c.ns, name, pt, data, subresources...), &v1alpha1.ContainerSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ContainerSource), err +} diff --git a/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_cronjobsource.go b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_cronjobsource.go new file mode 100644 index 000000000..59a9680b9 --- /dev/null +++ b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_cronjobsource.go @@ -0,0 +1,140 @@ +/* +Copyright 2019 The Knative Authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" + v1alpha1 "knative.dev/eventing/pkg/apis/sources/v1alpha1" +) + +// FakeCronJobSources implements CronJobSourceInterface +type FakeCronJobSources struct { + Fake *FakeSourcesV1alpha1 + ns string +} + +var cronjobsourcesResource = schema.GroupVersionResource{Group: "sources.eventing.knative.dev", Version: "v1alpha1", Resource: "cronjobsources"} + +var cronjobsourcesKind = schema.GroupVersionKind{Group: "sources.eventing.knative.dev", Version: "v1alpha1", Kind: "CronJobSource"} + +// Get takes name of the cronJobSource, and returns the corresponding cronJobSource object, and an error if there is any. +func (c *FakeCronJobSources) Get(name string, options v1.GetOptions) (result *v1alpha1.CronJobSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(cronjobsourcesResource, c.ns, name), &v1alpha1.CronJobSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.CronJobSource), err +} + +// List takes label and field selectors, and returns the list of CronJobSources that match those selectors. +func (c *FakeCronJobSources) List(opts v1.ListOptions) (result *v1alpha1.CronJobSourceList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(cronjobsourcesResource, cronjobsourcesKind, c.ns, opts), &v1alpha1.CronJobSourceList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &v1alpha1.CronJobSourceList{ListMeta: obj.(*v1alpha1.CronJobSourceList).ListMeta} + for _, item := range obj.(*v1alpha1.CronJobSourceList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested cronJobSources. +func (c *FakeCronJobSources) Watch(opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(cronjobsourcesResource, c.ns, opts)) + +} + +// Create takes the representation of a cronJobSource and creates it. Returns the server's representation of the cronJobSource, and an error, if there is any. +func (c *FakeCronJobSources) Create(cronJobSource *v1alpha1.CronJobSource) (result *v1alpha1.CronJobSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(cronjobsourcesResource, c.ns, cronJobSource), &v1alpha1.CronJobSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.CronJobSource), err +} + +// Update takes the representation of a cronJobSource and updates it. Returns the server's representation of the cronJobSource, and an error, if there is any. +func (c *FakeCronJobSources) Update(cronJobSource *v1alpha1.CronJobSource) (result *v1alpha1.CronJobSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(cronjobsourcesResource, c.ns, cronJobSource), &v1alpha1.CronJobSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.CronJobSource), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeCronJobSources) UpdateStatus(cronJobSource *v1alpha1.CronJobSource) (*v1alpha1.CronJobSource, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(cronjobsourcesResource, "status", c.ns, cronJobSource), &v1alpha1.CronJobSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.CronJobSource), err +} + +// Delete takes name of the cronJobSource and deletes it. Returns an error if one occurs. +func (c *FakeCronJobSources) Delete(name string, options *v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteAction(cronjobsourcesResource, c.ns, name), &v1alpha1.CronJobSource{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeCronJobSources) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(cronjobsourcesResource, c.ns, listOptions) + + _, err := c.Fake.Invokes(action, &v1alpha1.CronJobSourceList{}) + return err +} + +// Patch applies the patch and returns the patched cronJobSource. +func (c *FakeCronJobSources) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.CronJobSource, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(cronjobsourcesResource, c.ns, name, pt, data, subresources...), &v1alpha1.CronJobSource{}) + + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.CronJobSource), err +} diff --git a/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_sources_client.go b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_sources_client.go new file mode 100644 index 000000000..9a5bcecf5 --- /dev/null +++ b/vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake/fake_sources_client.go @@ -0,0 +1,48 @@ +/* +Copyright 2019 The Knative Authors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + rest "k8s.io/client-go/rest" + testing "k8s.io/client-go/testing" + v1alpha1 "knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1" +) + +type FakeSourcesV1alpha1 struct { + *testing.Fake +} + +func (c *FakeSourcesV1alpha1) ApiServerSources(namespace string) v1alpha1.ApiServerSourceInterface { + return &FakeApiServerSources{c, namespace} +} + +func (c *FakeSourcesV1alpha1) ContainerSources(namespace string) v1alpha1.ContainerSourceInterface { + return &FakeContainerSources{c, namespace} +} + +func (c *FakeSourcesV1alpha1) CronJobSources(namespace string) v1alpha1.CronJobSourceInterface { + return &FakeCronJobSources{c, namespace} +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *FakeSourcesV1alpha1) RESTClient() rest.Interface { + var ret *rest.RESTClient + return ret +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 389d9eb46..6a5115b3c 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -622,6 +622,7 @@ k8s.io/utils/buffer k8s.io/utils/trace # knative.dev/eventing v0.10.0 knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1 +knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1alpha1/fake knative.dev/eventing/pkg/apis/sources/v1alpha1 knative.dev/eventing/pkg/client/clientset/versioned/scheme knative.dev/eventing/pkg/apis/duck