knative
/
client
mirror of https://github.com/knative/client.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add support for Eventing/v1beta2 EventTypes (#1831) 

* Add support for Eventing/v1beta2 EventTypes

* Skip e2e tests on missing API

* Shortne the sink help message

* Reword the help by the review recommendation

* Reflect review feedback
This commit is contained in:
David Simansky 2023-07-26 12:42:40 +02:00 committed by GitHub
parent 3ecb24f1c1
commit 3a7d8c18ad
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
45 changed files with 468 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
docs/cmd/kn_eventtype_create.md
View File

@ -21,9 +21,10 @@ kn eventtype create
### Options
```
-b, --broker string Cloud Event broker
-b, --broker string Cloud Event Broker
-h, --help help for create
-n, --namespace string Specify the namespace to operate in.
-r, --reference string Addressable Reference producing events. You can specify a broker, channel, or fully qualified GroupVersionResource (GVR). Examples: '--reference broker:nest' for a broker 'nest', '--reference channel:pipe' for a channel 'pipe', '--reference special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'.
--source string Cloud Event source
-t, --type string Cloud Event type
```

2
docs/cmd/kn_source_apiserver_create.md
View File

@ -26,7 +26,7 @@ kn source apiserver create NAME --resource RESOURCE --sink SINK
--resource stringArray Specification for which events to listen, in the format Kind:APIVersion:LabelSelector, e.g. "Event:sourcesv1:key=value".
"LabelSelector" is a list of comma separated key value pairs. "LabelSelector" can be omitted, e.g. "Event:sourcesv1".
--service-account string Name of the service account to use to run this source
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
```
### Options inherited from parent commands

2
docs/cmd/kn_source_apiserver_update.md
View File

@ -26,7 +26,7 @@ kn source apiserver update NAME
--resource stringArray Specification for which events to listen, in the format Kind:APIVersion:LabelSelector, e.g. "Event:sourcesv1:key=value".
"LabelSelector" is a list of comma separated key value pairs. "LabelSelector" can be omitted, e.g. "Event:sourcesv1".
--service-account string Name of the service account to use to run this source
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
```
### Options inherited from parent commands

2
docs/cmd/kn_source_binding_create.md
View File

@ -20,7 +20,7 @@ kn source binding create NAME --subject SUBJECT --sink SINK
--ce-override stringArray Cloud Event overrides to apply before sending event to sink. Example: '--ce-override key=value' You may be provide this flag multiple times. To unset, append "-" to the key (e.g. --ce-override key-).
-h, --help help for create
-n, --namespace string Specify the namespace to operate in.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
--subject string Subject which emits cloud events. This argument takes format kind:apiVersion:name for named resources or kind:apiVersion:labelKey1=value1,labelKey2=value2 for matching via a label selector
```

2
docs/cmd/kn_source_binding_update.md
View File

@ -20,7 +20,7 @@ kn source binding update NAME
--ce-override stringArray Cloud Event overrides to apply before sending event to sink. Example: '--ce-override key=value' You may be provide this flag multiple times. To unset, append "-" to the key (e.g. --ce-override key-).
-h, --help help for update
-n, --namespace string Specify the namespace to operate in.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
--subject string Subject which emits cloud events. This argument takes format kind:apiVersion:name for named resources or kind:apiVersion:labelKey1=value1,labelKey2=value2 for matching via a label selector
```

2
docs/cmd/kn_source_container_create.md
View File

@ -39,7 +39,7 @@ kn source container create NAME --image IMAGE --sink SINK
--request strings The resource requirement requests for this Service. For example, 'cpu=100m,memory=256Mi'. You can use this flag multiple times. To unset a resource request, append "-" to the resource name, e.g. '--request cpu-'.
--security-context string Security Context definition to be added the service. Accepted values: strict | none. (default "strict")
--service-account string Service account name to set. An empty argument ("") clears the service account. The referenced service account must exist in the service's namespace.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
--user int The user ID to run the container (e.g., 1001).
--volume stringArray Add a volume from a ConfigMap (prefix cm: or config-map:) a Secret (prefix secret: or sc:), an EmptyDir (prefix ed: or emptyDir:) or a PersistentVolumeClaim (prefix pvc: or persistentVolumeClaim). Example: --volume myvolume=cm:myconfigmap, --volume myvolume=secret:mysecret or --volume emptyDir:myvol:size=1Gi,type=Memory. You can use this flag multiple times. To unset a ConfigMap/Secret reference, append "-" to the name, e.g. --volume myvolume-.
```

2
docs/cmd/kn_source_container_update.md
View File

@ -39,7 +39,7 @@ kn source container update NAME --image IMAGE
--request strings The resource requirement requests for this Service. For example, 'cpu=100m,memory=256Mi'. You can use this flag multiple times. To unset a resource request, append "-" to the resource name, e.g. '--request cpu-'.
--security-context string Security Context definition to be added the service. Accepted values: strict | none. (default "strict")
--service-account string Service account name to set. An empty argument ("") clears the service account. The referenced service account must exist in the service's namespace.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
--user int The user ID to run the container (e.g., 1001).
--volume stringArray Add a volume from a ConfigMap (prefix cm: or config-map:) a Secret (prefix secret: or sc:), an EmptyDir (prefix ed: or emptyDir:) or a PersistentVolumeClaim (prefix pvc: or persistentVolumeClaim). Example: --volume myvolume=cm:myconfigmap, --volume myvolume=secret:mysecret or --volume emptyDir:myvol:size=1Gi,type=Memory. You can use this flag multiple times. To unset a ConfigMap/Secret reference, append "-" to the name, e.g. --volume myvolume-.
```

2
docs/cmd/kn_source_ping_create.md
View File

@ -23,7 +23,7 @@ kn source ping create NAME --sink SINK
-h, --help help for create
-n, --namespace string Specify the namespace to operate in.
--schedule string Optional schedule specification in crontab format (e.g. '*/2 * * * *' for every two minutes. By default fire every minute.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
```
### Options inherited from parent commands

2
docs/cmd/kn_source_ping_update.md
View File

@ -23,7 +23,7 @@ kn source ping update NAME
-h, --help help for update
-n, --namespace string Specify the namespace to operate in.
--schedule string Optional schedule specification in crontab format (e.g. '*/2 * * * *' for every two minutes. By default fire every minute.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
```
### Options inherited from parent commands

6
docs/cmd/kn_subscription_create.md
View File

@ -23,9 +23,9 @@ kn subscription create NAME
--channel string Specify the channel to subscribe to. For the default channel, just use the name (e.g. 'mychannel'). A mapped channel type like 'imc' can be used as a prefix (e.g. 'imc:mychannel'). Finally you can specify the full coordinates to the referenced channel with Group:Version:Kind:Name (e.g. 'messaging.knative.dev:v1alpha1:KafkaChannel:mychannel').
-h, --help help for create
-n, --namespace string Specify the namespace to operate in.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
--sink-dead-letter string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink-dead-letter broker:nest' for a broker 'nest', '--sink-dead-letter channel:pipe' for a channel 'pipe', '--sink-dead-letter ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink-dead-letter https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink-dead-letter ksvc:receiver' or simply '--sink-dead-letter receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
--sink-reply string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink-reply broker:nest' for a broker 'nest', '--sink-reply channel:pipe' for a channel 'pipe', '--sink-reply ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink-reply https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink-reply ksvc:receiver' or simply '--sink-reply receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
--sink-dead-letter string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink-dead-letter broker:nest' for a broker 'nest', '--sink-dead-letter channel:pipe' for a channel 'pipe', '--sink-dead-letter ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink-dead-letter https://event.receiver.uri' for an HTTP URI, '--sink-dead-letter ksvc:receiver' or simply '--sink-dead-letter receiver' for a Knative service 'receiver' in the current namespace. '--sink-dead-letter special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
--sink-reply string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink-reply broker:nest' for a broker 'nest', '--sink-reply channel:pipe' for a channel 'pipe', '--sink-reply ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink-reply https://event.receiver.uri' for an HTTP URI, '--sink-reply ksvc:receiver' or simply '--sink-reply receiver' for a Knative service 'receiver' in the current namespace. '--sink-reply special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
```
### Options inherited from parent commands

6
docs/cmd/kn_subscription_update.md
View File

@ -22,9 +22,9 @@ kn subscription update NAME
```
-h, --help help for update
-n, --namespace string Specify the namespace to operate in.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
--sink-dead-letter string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink-dead-letter broker:nest' for a broker 'nest', '--sink-dead-letter channel:pipe' for a channel 'pipe', '--sink-dead-letter ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink-dead-letter https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink-dead-letter ksvc:receiver' or simply '--sink-dead-letter receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
--sink-reply string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink-reply broker:nest' for a broker 'nest', '--sink-reply channel:pipe' for a channel 'pipe', '--sink-reply ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink-reply https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink-reply ksvc:receiver' or simply '--sink-reply receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
--sink-dead-letter string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink-dead-letter broker:nest' for a broker 'nest', '--sink-dead-letter channel:pipe' for a channel 'pipe', '--sink-dead-letter ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink-dead-letter https://event.receiver.uri' for an HTTP URI, '--sink-dead-letter ksvc:receiver' or simply '--sink-dead-letter receiver' for a Knative service 'receiver' in the current namespace. '--sink-dead-letter special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
--sink-reply string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink-reply broker:nest' for a broker 'nest', '--sink-reply channel:pipe' for a channel 'pipe', '--sink-reply ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink-reply https://event.receiver.uri' for an HTTP URI, '--sink-reply ksvc:receiver' or simply '--sink-reply receiver' for a Knative service 'receiver' in the current namespace. '--sink-reply special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
```
### Options inherited from parent commands

2
docs/cmd/kn_trigger_create.md
View File

@ -24,7 +24,7 @@ kn trigger create NAME --sink SINK
--filter strings Key-value pair for exact CloudEvent attribute matching against incoming events, e.g type=dev.knative.foo
-h, --help help for create
-n, --namespace string Specify the namespace to operate in.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
```
### Options inherited from parent commands

2
docs/cmd/kn_trigger_update.md
View File

@ -28,7 +28,7 @@ kn trigger update NAME
--filter strings Key-value pair for exact CloudEvent attribute matching against incoming events, e.g type=dev.knative.foo
-h, --help help for update
-n, --namespace string Specify the namespace to operate in.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. If a prefix is not provided, it is considered as a Knative service in the current namespace. If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly.
-s, --sink string Addressable sink for events. You can specify a broker, channel, Knative service or URI. Examples: '--sink broker:nest' for a broker 'nest', '--sink channel:pipe' for a channel 'pipe', '--sink ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', '--sink https://event.receiver.uri' for an HTTP URI, '--sink ksvc:receiver' or simply '--sink receiver' for a Knative service 'receiver' in the current namespace. '--sink special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. If a prefix is not provided, it is considered as a Knative service in the current namespace.
```
### Options inherited from parent commands

1
hack/build.sh
View File

@ -110,6 +110,7 @@ codegen() {
# Auto generate cli docs
generate_docs
}
go_fmt() {

54
pkg/eventing/v1beta1/client.go → pkg/eventing/v1beta2/client.go
View File

@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package v1beta1
package v1beta2
import (
"context"
@ -21,35 +21,37 @@ import (
"k8s.io/apimachinery/pkg/runtime"
kn_errors "knative.dev/client/pkg/errors"
"knative.dev/client/pkg/util"
eventingv1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
eventingv1 "knative.dev/eventing/pkg/apis/eventing/v1"
eventingv1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
"knative.dev/eventing/pkg/client/clientset/versioned/scheme"
beta1 "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1"
beta1 "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2"
"knative.dev/pkg/apis"
v1 "knative.dev/pkg/apis/duck/v1"
)
// KnEventingV1Beta1Client to Eventing Sources. All methods are relative to the
// KnEventingV1Beta2Client to Eventing Sources. All methods are relative to the
// namespace specified during construction
type KnEventingV1Beta1Client interface {
type KnEventingV1Beta2Client interface {
// Namespace in which this client is operating for
Namespace() string
// ListEventtypes is used to list eventtypes
ListEventtypes(ctx context.Context) (*eventingv1beta1.EventTypeList, error)
ListEventtypes(ctx context.Context) (*eventingv1beta2.EventTypeList, error)
// GetEventtype is used to describe an eventtype
GetEventtype(ctx context.Context, name string) (*eventingv1beta1.EventType, error)
GetEventtype(ctx context.Context, name string) (*eventingv1beta2.EventType, error)
// CreateEventtype is used to create an eventtype
CreateEventtype(ctx context.Context, eventtype *eventingv1beta1.EventType) error
CreateEventtype(ctx context.Context, eventtype *eventingv1beta2.EventType) error
// DeleteEventtype is used to delete an eventtype
DeleteEventtype(ctx context.Context, name string) error
}
// KnEventingV1Beta1Client is a client for eventing v1beta1 resources
// KnEventingV1Beta2Client is a client for eventing v1beta2 resources
type knEventingV1Beta1Client struct {
client beta1.EventingV1beta1Interface
client beta1.EventingV1beta2Interface
namespace string
}
// NewKnEventingV1Beta1Client is to invoke Eventing Types Client API to create object
func NewKnEventingV1Beta1Client(client beta1.EventingV1beta1Interface, namespace string) KnEventingV1Beta1Client {
// NewKnEventingV1Beta2Client is to invoke Eventing Types Client API to create object
func NewKnEventingV1Beta2Client(client beta1.EventingV1beta2Interface, namespace string) KnEventingV1Beta2Client {
return &knEventingV1Beta1Client{
client: client,
namespace: namespace,
@ -57,14 +59,14 @@ func NewKnEventingV1Beta1Client(client beta1.EventingV1beta1Interface, namespace
}
func updateEventingBeta1GVK(obj runtime.Object) error {
return util.UpdateGroupVersionKindWithScheme(obj, eventingv1beta1.SchemeGroupVersion, scheme.Scheme)
return util.UpdateGroupVersionKindWithScheme(obj, eventingv1beta2.SchemeGroupVersion, scheme.Scheme)
}
func (c *knEventingV1Beta1Client) Namespace() string {
return c.namespace
}
func (c *knEventingV1Beta1Client) ListEventtypes(ctx context.Context) (*eventingv1beta1.EventTypeList, error) {
func (c *knEventingV1Beta1Client) ListEventtypes(ctx context.Context) (*eventingv1beta2.EventTypeList, error) {
eventTypeList, err := c.client.EventTypes(c.namespace).List(ctx, apis_v1.ListOptions{})
if err != nil {
return nil, kn_errors.GetError(err)
@ -75,7 +77,7 @@ func (c *knEventingV1Beta1Client) ListEventtypes(ctx context.Context) (*eventing
return nil, err
}
listNew.Items = make([]eventingv1beta1.EventType, len(eventTypeList.Items))
listNew.Items = make([]eventingv1beta2.EventType, len(eventTypeList.Items))
for idx, eventType := range eventTypeList.Items {
clone := eventType.DeepCopy()
err := updateEventingBeta1GVK(clone)
@ -87,7 +89,7 @@ func (c *knEventingV1Beta1Client) ListEventtypes(ctx context.Context) (*eventing
return listNew, nil
}
func (c *knEventingV1Beta1Client) GetEventtype(ctx context.Context, name string) (*eventingv1beta1.EventType, error) {
func (c *knEventingV1Beta1Client) GetEventtype(ctx context.Context, name string) (*eventingv1beta2.EventType, error) {
eventType, err := c.client.EventTypes(c.namespace).Get(ctx, name, apis_v1.GetOptions{})
if err != nil {
return nil, kn_errors.GetError(err)
@ -107,7 +109,7 @@ func (c *knEventingV1Beta1Client) DeleteEventtype(ctx context.Context, name stri
return nil
}
func (c *knEventingV1Beta1Client) CreateEventtype(ctx context.Context, eventtype *eventingv1beta1.EventType) error {
func (c *knEventingV1Beta1Client) CreateEventtype(ctx context.Context, eventtype *eventingv1beta2.EventType) error {
_, err := c.client.EventTypes(c.namespace).Create(ctx, eventtype, apis_v1.CreateOptions{})
if err != nil {
return kn_errors.GetError(err)
@ -117,12 +119,12 @@ func (c *knEventingV1Beta1Client) CreateEventtype(ctx context.Context, eventtype
// EventtypeBuilder is for building the eventtype
type EventtypeBuilder struct {
eventtype *eventingv1beta1.EventType
eventtype *eventingv1beta2.EventType
}
// NewEventtypeBuilder for building eventtype object
func NewEventtypeBuilder(name string) *EventtypeBuilder {
return &EventtypeBuilder{eventtype: &eventingv1beta1.EventType{
return &EventtypeBuilder{eventtype: &eventingv1beta2.EventType{
ObjectMeta: apis_v1.ObjectMeta{
Name: name,
},
@ -155,11 +157,21 @@ func (e *EventtypeBuilder) Source(source *apis.URL) *EventtypeBuilder {
// Broker for eventtype builder
func (e *EventtypeBuilder) Broker(broker string) *EventtypeBuilder {
e.eventtype.Spec.Broker = broker
e.eventtype.Spec.Reference = &v1.KReference{
APIVersion: eventingv1.SchemeGroupVersion.String(),
Kind: "Broker",
Name: broker,
}
return e
}
// Reference for eventtype builder
func (e *EventtypeBuilder) Reference(ref *v1.KReference) *EventtypeBuilder {
e.eventtype.Spec.Reference = ref
return e
}
// Build to return an instance of eventtype object
func (e *EventtypeBuilder) Build() *eventingv1beta1.EventType {
func (e *EventtypeBuilder) Build() *eventingv1beta2.EventType {
return e.eventtype
}

50
pkg/eventing/v1beta1/client_mock.go → pkg/eventing/v1beta2/client_mock.go
View File

@ -12,95 +12,95 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package v1beta1
package v1beta2
import (
"context"
"testing"
eventingv1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
eventingv1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
"knative.dev/client/pkg/util/mock"
)
// MockKnEventingV1beta1Client is a combine of test object and recorder
type MockKnEventingV1beta1Client struct {
// MockKnEventingV1beta2Client is a combine of test object and recorder
type MockKnEventingV1beta2Client struct {
t *testing.T
recorder *EventingV1beta1Recorder
recorder *EventingV1beta2Recorder
}
// NewMockKnEventingV1beta1Client returns a new mock instance which you need to record for
func NewMockKnEventingV1beta1Client(t *testing.T, ns ...string) *MockKnEventingV1beta1Client {
// NewMockKnEventingV1beta2Client returns a new mock instance which you need to record for
func NewMockKnEventingV1beta2Client(t *testing.T, ns ...string) *MockKnEventingV1beta2Client {
namespace := "default"
if len(ns) > 0 {
namespace = ns[0]
}
return &MockKnEventingV1beta1Client{
return &MockKnEventingV1beta2Client{
t: t,
recorder: &EventingV1beta1Recorder{mock.NewRecorder(t, namespace)},
recorder: &EventingV1beta2Recorder{mock.NewRecorder(t, namespace)},
}
}
// Ensure that the interface is implemented
var _ KnEventingV1Beta1Client = &MockKnEventingV1beta1Client{}
var _ KnEventingV1Beta2Client = &MockKnEventingV1beta2Client{}
// EventingV1beta1Recorder is recorder for eventingv1beta1 objects
type EventingV1beta1Recorder struct {
// EventingV1beta2Recorder is recorder for eventingv1beta2 objects
type EventingV1beta2Recorder struct {
r *mock.Recorder
}
// Recorder returns the recorder for registering API calls
func (c *MockKnEventingV1beta1Client) Recorder() *EventingV1beta1Recorder {
func (c *MockKnEventingV1beta2Client) Recorder() *EventingV1beta2Recorder {
return c.recorder
}
// Namespace of this client
func (c *MockKnEventingV1beta1Client) Namespace() string {
func (c *MockKnEventingV1beta2Client) Namespace() string {
return c.recorder.r.Namespace()
}
// ListEventtypes records a call for ListEventtypes with the expected result and error (nil if none)
func (sr *EventingV1beta1Recorder) ListEventtypes(eventtypeList *eventingv1beta1.EventTypeList, err error) {
func (sr *EventingV1beta2Recorder) ListEventtypes(eventtypeList *eventingv1beta2.EventTypeList, err error) {
sr.r.Add("ListEventtypes", nil, []interface{}{eventtypeList, err})
}
func (c *MockKnEventingV1beta1Client) ListEventtypes(ctx context.Context) (*eventingv1beta1.EventTypeList, error) {
func (c *MockKnEventingV1beta2Client) ListEventtypes(ctx context.Context) (*eventingv1beta2.EventTypeList, error) {
call := c.recorder.r.VerifyCall("ListEventtypes")
return call.Result[0].(*eventingv1beta1.EventTypeList), mock.ErrorOrNil(call.Result[1])
return call.Result[0].(*eventingv1beta2.EventTypeList), mock.ErrorOrNil(call.Result[1])
}
// GetEventtype records a call for GetEventtype with the expected result and error (nil if none)
func (sr *EventingV1beta1Recorder) GetEventtype(name string, eventtype *eventingv1beta1.EventType, err error) {
func (sr *EventingV1beta2Recorder) GetEventtype(name string, eventtype *eventingv1beta2.EventType, err error) {
sr.r.Add("GetEventtype", []interface{}{name}, []interface{}{eventtype, err})
}
// GetEventtypes records a call for GetEventtype with the expected object or error. Either eventtype or err should be nil
func (c *MockKnEventingV1beta1Client) GetEventtype(ctx context.Context, name string) (*eventingv1beta1.EventType, error) {
func (c *MockKnEventingV1beta2Client) GetEventtype(ctx context.Context, name string) (*eventingv1beta2.EventType, error) {
call := c.recorder.r.VerifyCall("GetEventtype", name)
return call.Result[0].(*eventingv1beta1.EventType), mock.ErrorOrNil(call.Result[1])
return call.Result[0].(*eventingv1beta2.EventType), mock.ErrorOrNil(call.Result[1])
}
// CreateEventtype records a call for CreateEventtype with the expected error
func (sr *EventingV1beta1Recorder) CreateEventtype(eventtype interface{}, err error) {
func (sr *EventingV1beta2Recorder) CreateEventtype(eventtype interface{}, err error) {
sr.r.Add("CreateEventtype", []interface{}{eventtype}, []interface{}{err})
}
func (c *MockKnEventingV1beta1Client) CreateEventtype(ctx context.Context, eventtype *eventingv1beta1.EventType) error {
func (c *MockKnEventingV1beta2Client) CreateEventtype(ctx context.Context, eventtype *eventingv1beta2.EventType) error {
call := c.recorder.r.VerifyCall("CreateEventtype", eventtype)
return mock.ErrorOrNil(call.Result[0])
}
// DeleteEventtype records a call for DeleteEventtype with the expected error
func (sr *EventingV1beta1Recorder) DeleteEventtype(name interface{}, err error) {
func (sr *EventingV1beta2Recorder) DeleteEventtype(name interface{}, err error) {
sr.r.Add("DeleteEventtype", []interface{}{name}, []interface{}{err})
}
func (c *MockKnEventingV1beta1Client) DeleteEventtype(ctx context.Context, name string) error {
func (c *MockKnEventingV1beta2Client) DeleteEventtype(ctx context.Context, name string) error {
call := c.recorder.r.VerifyCall("DeleteEventtype", name)
return mock.ErrorOrNil(call.Result[0])
}
// Validate validates whether every recorded action has been called
func (sr *EventingV1beta1Recorder) Validate() {
func (sr *EventingV1beta2Recorder) Validate() {
sr.r.CheckThatAllRecordedMethodsHaveBeenCalled()
}

14
pkg/eventing/v1beta1/client_mock_test.go → pkg/eventing/v1beta2/client_mock_test.go
View File

@ -12,27 +12,27 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package v1beta1
package v1beta2
import (
"context"
"testing"
"knative.dev/eventing/pkg/apis/eventing/v1beta1"
"knative.dev/eventing/pkg/apis/eventing/v1beta2"
)
func TestMockKnClient(t *testing.T) {
client := NewMockKnEventingV1beta1Client(t, "test-ns")
client := NewMockKnEventingV1beta2Client(t, "test-ns")
recorder := client.Recorder()
recorder.CreateEventtype(&v1beta1.EventType{}, nil)
recorder.GetEventtype("eventtype-name", &v1beta1.EventType{}, nil)
recorder.CreateEventtype(&v1beta2.EventType{}, nil)
recorder.GetEventtype("eventtype-name", &v1beta2.EventType{}, nil)
recorder.DeleteEventtype("eventtype-name", nil)
recorder.ListEventtypes(&v1beta1.EventTypeList{}, nil)
recorder.ListEventtypes(&v1beta2.EventTypeList{}, nil)
ctx := context.Background()
client.CreateEventtype(ctx, &v1beta1.EventType{})
client.CreateEventtype(ctx, &v1beta2.EventType{})
client.GetEventtype(ctx, "eventtype-name")
client.DeleteEventtype(ctx, "eventtype-name")
client.ListEventtypes(ctx)

48
pkg/eventing/v1beta1/client_test.go → pkg/eventing/v1beta2/client_test.go
View File

@ -12,19 +12,22 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package v1beta1
package v1beta2
import (
"context"
"fmt"
"testing"
eventingv1 "knative.dev/eventing/pkg/apis/eventing/v1"
v1 "knative.dev/pkg/apis/duck/v1"
"gotest.tools/v3/assert"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
client_testing "k8s.io/client-go/testing"
"knative.dev/eventing/pkg/apis/eventing/v1beta1"
"knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/fake"
"knative.dev/eventing/pkg/apis/eventing/v1beta2"
"knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/fake"
"knative.dev/pkg/apis"
)
@ -37,9 +40,9 @@ const (
errName = "error-eventtype"
)
func setup(ns string) (fakeSvr fake.FakeEventingV1beta1, client KnEventingV1Beta1Client) {
fakeE := fake.FakeEventingV1beta1{Fake: &client_testing.Fake{}}
cli := NewKnEventingV1Beta1Client(&fakeE, ns)
func setup(ns string) (fakeSvr fake.FakeEventingV1beta2, client KnEventingV1Beta2Client) {
fakeE := fake.FakeEventingV1beta2{Fake: &client_testing.Fake{}}
cli := NewKnEventingV1Beta2Client(&fakeE, ns)
return fakeE, cli
}
@ -51,7 +54,21 @@ func TestNamespace(t *testing.T) {
func TestBuilder(t *testing.T) {
et := newEventtypeWithSourceBroker(testName, testSource, testBroker)
assert.Equal(t, et.Name, testName)
assert.Equal(t, et.Spec.Broker, testBroker)
assert.Equal(t, et.Spec.Reference.Name, testBroker)
source := et.Spec.Source
assert.Assert(t, source != nil)
assert.Equal(t, source.String(), testSource)
}
func TestBuilderWithRefence(t *testing.T) {
ref := &v1.KReference{
APIVersion: eventingv1.SchemeGroupVersion.String(),
Kind: "Broker",
Name: testBroker,
}
et := newEventtypeWithSourceRef(testName, testSource, ref)
assert.Equal(t, et.Name, testName)
assert.Equal(t, et.Spec.Reference, ref)
source := et.Spec.Source
assert.Assert(t, source != nil)
assert.Equal(t, source.String(), testSource)
@ -147,7 +164,7 @@ func TestKnEventingV1Beta1Client_ListEventtypes(t *testing.T) {
func(a client_testing.Action) (bool, runtime.Object, error) {
assert.Equal(t, testNamespace, a.GetNamespace())
return true, &v1beta1.EventTypeList{Items: []v1beta1.EventType{
return true, &v1beta2.EventTypeList{Items: []v1beta2.EventType{
*newEventtype("eventtype-1"),
*newEventtype("eventtype-2")}}, nil
})
@ -161,7 +178,7 @@ func TestKnEventingV1Beta1Client_ListEventtypes(t *testing.T) {
assert.Equal(t, list.Items[1].Name, "eventtype-2")
}
func newEventtypeWithSourceBroker(name string, source string, broker string) *v1beta1.EventType {
func newEventtypeWithSourceBroker(name string, source string, broker string) *v1beta2.EventType {
url, _ := apis.ParseURL(source)
return NewEventtypeBuilder(name).
Namespace(testNamespace).
@ -172,7 +189,18 @@ func newEventtypeWithSourceBroker(name string, source string, broker string) *v1
Build()
}
func newEventtype(name string) *v1beta1.EventType {
func newEventtypeWithSourceRef(name string, source string, ref *v1.KReference) *v1beta2.EventType {
url, _ := apis.ParseURL(source)
return NewEventtypeBuilder(name).
Namespace(testNamespace).
WithGvk().
Type(testType).
Source(url).
Reference(ref).
Build()
}
func newEventtype(name string) *v1beta2.EventType {
return NewEventtypeBuilder(name).
Namespace(testNamespace).
Type(testType).

4
pkg/kn/commands/broker/delivery_option_flags.go
View File

@ -15,6 +15,8 @@
package broker
import (
"reflect"
"github.com/spf13/cobra"
"knative.dev/client/pkg/dynamic"
"knative.dev/client/pkg/kn/commands/flags"
@ -50,7 +52,7 @@ func (d *DeliveryOptionFlags) GetDlSink(cmd *cobra.Command, dynamicClient dynami
var empty = flags.SinkFlags{}
var destination *duckv1.Destination
var err error
if d.SinkFlags != empty {
if !reflect.DeepEqual(d.SinkFlags, empty) {
destination, err = d.SinkFlags.ResolveSink(cmd.Context(), dynamicClient, namespace)
if err != nil {
return nil, err

2
pkg/kn/commands/completion_helper.go
View File

@ -439,7 +439,7 @@ func completeEventtype(config *completionConfig) (suggestions []string) {
return
}
client, err := config.params.NewEventingV1beta1Client(namespace)
client, err := config.params.NewEventingV1beta2Client(namespace)
if err != nil {
return
}

24
pkg/kn/commands/completion_helper_test.go
View File

@ -25,12 +25,12 @@ import (
"k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/tools/clientcmd"
clienteventingv1beta1 "knative.dev/client/pkg/eventing/v1beta1"
clienteventingv1beta2 "knative.dev/client/pkg/eventing/v1beta2"
v1beta1 "knative.dev/client/pkg/messaging/v1"
clientv1alpha1 "knative.dev/client/pkg/serving/v1alpha1"
clientsourcesv1 "knative.dev/client/pkg/sources/v1"
"knative.dev/client/pkg/sources/v1beta2"
eventingv1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
eventingv1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
messagingv1 "knative.dev/eventing/pkg/apis/messaging/v1"
sourcesv1 "knative.dev/eventing/pkg/apis/sources/v1"
sourcesv1beta2 "knative.dev/eventing/pkg/apis/sources/v1beta2"
@ -45,7 +45,7 @@ import (
eventingv1 "knative.dev/eventing/pkg/apis/eventing/v1"
"knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1/fake"
beta1fake "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/fake"
beta2fake "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/fake"
servingv1 "knative.dev/serving/pkg/apis/serving/v1"
"knative.dev/serving/pkg/apis/serving/v1alpha1"
servingv1fake "knative.dev/serving/pkg/client/clientset/versioned/typed/serving/v1/fake"
@ -387,29 +387,29 @@ var (
)
var (
testEventtype1 = eventingv1beta1.EventType{
testEventtype1 = eventingv1beta2.EventType{
TypeMeta: metav1.TypeMeta{
Kind: "EventType",
APIVersion: "eventing.knative.dev/v1beta1",
},
ObjectMeta: metav1.ObjectMeta{Name: "test-eventtype-1", Namespace: testNs},
}
testEventtype2 = eventingv1beta1.EventType{
testEventtype2 = eventingv1beta2.EventType{
TypeMeta: metav1.TypeMeta{
Kind: "EventType",
APIVersion: "eventing.knative.dev/v1beta1",
},
ObjectMeta: metav1.ObjectMeta{Name: "test-eventtype-2", Namespace: testNs},
}
testEventtype3 = eventingv1beta1.EventType{
testEventtype3 = eventingv1beta2.EventType{
TypeMeta: metav1.TypeMeta{
Kind: "EventType",
APIVersion: "eventing.knative.dev/v1beta1",
},
ObjectMeta: metav1.ObjectMeta{Name: "test-eventtype-3", Namespace: testNs},
}
testEventtypes = []eventingv1beta1.EventType{testEventtype1, testEventtype2, testEventtype3}
fakeEventingBeta1Client = &beta1fake.FakeEventingV1beta1{Fake: &clienttesting.Fake{}}
testEventtypes = []eventingv1beta2.EventType{testEventtype1, testEventtype2, testEventtype3}
fakeEventingBeta2Client = &beta2fake.FakeEventingV1beta2{Fake: &clienttesting.Fake{}}
)
var knParams = initialiseKnParams()
@ -452,8 +452,8 @@ current-context: x
NewSourcesV1beta2Client: func(namespace string) (v1beta2.KnSourcesClient, error) {
return v1beta2.NewKnSourcesClient(fakeSourcesV1Beta2, namespace), nil
},
NewEventingV1beta1Client: func(namespace string) (clienteventingv1beta1.KnEventingV1Beta1Client, error) {
return clienteventingv1beta1.NewKnEventingV1Beta1Client(fakeEventingBeta1Client, namespace), nil
NewEventingV1beta2Client: func(namespace string) (clienteventingv1beta2.KnEventingV1Beta2Client, error) {
return clienteventingv1beta2.NewKnEventingV1Beta2Client(fakeEventingBeta2Client, namespace), nil
},
ClientConfig: blankConfig,
}
@ -1499,11 +1499,11 @@ func TestResourceNameCompletionFuncSubscription(t *testing.T) {
func TestResourceNameCompletionFuncEventtype(t *testing.T) {
completionFunc := ResourceNameCompletionFunc(knParams)
fakeEventingBeta1Client.AddReactor("list", "eventtypes", func(a clienttesting.Action) (bool, runtime.Object, error) {
fakeEventingBeta2Client.AddReactor("list", "eventtypes", func(a clienttesting.Action) (bool, runtime.Object, error) {
if a.GetNamespace() == errorNs {
return true, nil, errors.NewInternalError(fmt.Errorf("unable to list eventtypes"))
}
return true, &eventingv1beta1.EventTypeList{Items: testEventtypes}, nil
return true, &eventingv1beta2.EventTypeList{Items: testEventtypes}, nil
})
tests := []testType{

43
pkg/kn/commands/eventtype/create.go
View File

@ -21,7 +21,7 @@ import (
"fmt"
"github.com/spf13/cobra"
clienteventingv1beta1 "knative.dev/client/pkg/eventing/v1beta1"
clienteventingv1beta2 "knative.dev/client/pkg/eventing/v1beta2"
"knative.dev/client/pkg/kn/commands"
knflags "knative.dev/client/pkg/kn/commands/flags"
"knative.dev/pkg/apis"
@ -39,6 +39,9 @@ var createExample = `
func NewEventtypeCreateCommand(p *commands.KnParams) *cobra.Command {
var eventtypeFlags knflags.EventtypeFlags
referenceFlag := knflags.NewSinkFlag(referenceMappings)
cmd := &cobra.Command{
Use: "create",
Short: "Create eventtype",
@ -49,30 +52,49 @@ func NewEventtypeCreateCommand(p *commands.KnParams) *cobra.Command {
}
name := args[0]
if eventtypeFlags.Broker != "" && referenceFlag.Sink != "" {
return errors.New("use only one of '--broker' or '--reference' flags")
}
namespace, err := p.GetNamespace(cmd)
if err != nil {
return eventtypeCreateError(name, namespace, err)
}
eventingV1Beta1Client, err := p.NewEventingV1beta1Client(namespace)
eventingV1Beta2Client, err := p.NewEventingV1beta2Client(namespace)
if err != nil {
return err
}
dynamicClient, err := p.NewDynamicClient(namespace)
if err != nil {
return err
}
var source *apis.URL
if eventtypeFlags.Source != "" {
source, err = apis.ParseURL(eventtypeFlags.Source)
if err != nil {
return eventtypeCreateError(name, namespace, err)
}
}
eventtype := clienteventingv1beta1.NewEventtypeBuilder(name).
etBuilder := clienteventingv1beta2.NewEventtypeBuilder(name).
Namespace(namespace).
Type(eventtypeFlags.Type).
Source(source).
Broker(eventtypeFlags.Broker).
Build()
Source(source)
err = eventingV1Beta1Client.CreateEventtype(cmd.Context(), eventtype)
if eventtypeFlags.Broker != "" {
etBuilder.Broker(eventtypeFlags.Broker)
}
if referenceFlag.Sink != "" {
dest, err := referenceFlag.ResolveSink(cmd.Context(), dynamicClient, namespace)
if err != nil {
return eventtypeCreateError(name, namespace, err)
}
etBuilder.Reference(dest.Ref)
}
err = eventingV1Beta2Client.CreateEventtype(cmd.Context(), etBuilder.Build())
if err != nil {
return eventtypeCreateError(name, namespace, err)
}
@ -82,6 +104,13 @@ func NewEventtypeCreateCommand(p *commands.KnParams) *cobra.Command {
}
commands.AddNamespaceFlags(cmd.Flags(), false)
referenceFlag.AddWithFlagName(cmd, "reference", "r")
flag := "reference"
cmd.Flag(flag).Usage = "Addressable Reference producing events. " +
"You can specify a broker, channel, or fully qualified GroupVersionResource (GVR). " +
"Examples: '--" + flag + " broker:nest' for a broker 'nest', " +
"'--" + flag + " channel:pipe' for a channel 'pipe', " +
"'--" + flag + " special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'."
eventtypeFlags.Add(cmd)
return cmd
}

43
pkg/kn/commands/eventtype/create_test.go
View File

@ -20,25 +20,28 @@ import (
"fmt"
"testing"
dynamicfake "knative.dev/client/pkg/dynamic/fake"
"gotest.tools/v3/assert"
"knative.dev/client/pkg/eventing/v1beta1"
"knative.dev/client/pkg/eventing/v1beta2"
"knative.dev/client/pkg/util"
"knative.dev/pkg/apis"
)
func TestEventTypeCreate(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.CreateEventtype(createEventtype(eventtypeName, cetype, testNs), nil)
out, err := executeEventtypeCommand(eventingClient, "create", eventtypeName, "--type", cetype, "--namespace", testNs)
out, err := executeEventtypeCommand(eventingClient, dynamicClient, "create", eventtypeName, "--type", cetype, "--namespace", testNs)
assert.NilError(t, err, "Eventtype should be created")
assert.Assert(t, util.ContainsAll(out, "Eventtype", eventtypeName, "created", "namespace", testNs))
// Create eventtype without namespace flag set
eventingRecorder.CreateEventtype(createEventtype(eventtypeName, cetype, "default"), nil)
out, err = executeEventtypeCommand(eventingClient, "create", eventtypeName, "--type", cetype)
out, err = executeEventtypeCommand(eventingClient, dynamicClient, "create", eventtypeName, "--type", cetype)
assert.NilError(t, err, "Eventtype should be created")
assert.Assert(t, util.ContainsAll(out, "Eventtype", eventtypeName, "created", "namespace", "default"))
@ -47,27 +50,30 @@ func TestEventTypeCreate(t *testing.T) {
}
func TestEventTypeCreateWithoutTypeError(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
_, err := executeEventtypeCommand(eventingClient, "create", eventtypeName, "--namespace", testNs)
_, err := executeEventtypeCommand(eventingClient, dynamicClient, "create", eventtypeName, "--namespace", testNs)
assert.Assert(t, util.ContainsAll(err.Error(), "required", "flag(s)", "type", "not", "set"))
}
func TestEventTypeCreateWithoutNameError(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
_, err := executeEventtypeCommand(eventingClient, "create", "--namespace", testNs, "--type", cetype)
_, err := executeEventtypeCommand(eventingClient, dynamicClient, "create", "--namespace", testNs, "--type", cetype)
assert.Assert(t, util.ContainsAll(err.Error(), "requires", "eventtype", "name"))
}
func TestEventTypeCreateWithSource(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
url, _ := apis.ParseURL(testSource)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.CreateEventtype(createEventtypeWithSource(eventtypeName, cetype, testNs, url), nil)
out, err := executeEventtypeCommand(eventingClient, "create", eventtypeName, "--type", cetype, "--source", testSource, "--namespace", testNs)
out, err := executeEventtypeCommand(eventingClient, dynamicClient, "create", eventtypeName, "--type", cetype, "--source", testSource, "--namespace", testNs)
assert.NilError(t, err, "Eventtype should be created")
assert.Assert(t, util.ContainsAll(out, "Eventtype", eventtypeName, "created", "namespace", testNs))
@ -77,20 +83,23 @@ func TestEventTypeCreateWithSource(t *testing.T) {
}
func TestEventTypeCreateWithSourceError(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
_, err := executeEventtypeCommand(eventingClient, "create", eventtypeName, "--type", cetype, "--source", testSourceError, "--namespace", testNs)
_, err := executeEventtypeCommand(eventingClient, dynamicClient, "create", eventtypeName, "--type", cetype, "--source", testSourceError, "--namespace", testNs)
assert.ErrorContains(t, err, "cannot create eventtype")
assert.Assert(t, util.ContainsAll(err.Error(), "invalid", "character", "URL"))
}
func TestEventTypeCreateWithBroker(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.CreateEventtype(createEventtypeWithBroker(eventtypeName, cetype, testBroker, testNs), nil)
out, err := executeEventtypeCommand(eventingClient, "create", eventtypeName, "--type", cetype, "--namespace", testNs, "--broker", testBroker)
out, err := executeEventtypeCommand(eventingClient, dynamicClient, "create", eventtypeName, "--type", cetype, "--namespace", testNs, "--broker", testBroker)
assert.NilError(t, err, "Eventtype should be created")
assert.Assert(t, util.ContainsAll(out, "Eventtype", eventtypeName, "created", "namespace", testNs))
@ -98,11 +107,13 @@ func TestEventTypeCreateWithBroker(t *testing.T) {
}
func TestEventTypeCreateWithError(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.CreateEventtype(createEventtype(eventtypeName, cetype, testNs), fmt.Errorf("mock-error"))
_, err := executeEventtypeCommand(eventingClient, "create", eventtypeName, "--type", cetype, "--namespace", testNs)
_, err := executeEventtypeCommand(eventingClient, dynamicClient, "create", eventtypeName, "--type", cetype, "--namespace", testNs)
assert.ErrorContains(t, err, "cannot create eventtype")
assert.Assert(t, util.ContainsAll(err.Error(), "mock-error"))

4
pkg/kn/commands/eventtype/delete.go
View File

@ -51,11 +51,11 @@ func NewEventtypeDeleteCommand(p *commands.KnParams) *cobra.Command {
return err
}
eventingV1Beta1Client, err := p.NewEventingV1beta1Client(namespace)
eventingV1Beta2Client, err := p.NewEventingV1beta2Client(namespace)
if err != nil {
return err
}
err = eventingV1Beta1Client.DeleteEventtype(cmd.Context(), name)
err = eventingV1Beta2Client.DeleteEventtype(cmd.Context(), name)
if err != nil {
return fmt.Errorf(
"cannot delete eventtype '%s' in namespace '%s' "+

19
pkg/kn/commands/eventtype/delete_test.go
View File

@ -20,18 +20,21 @@ import (
"fmt"
"testing"
dynamicfake "knative.dev/client/pkg/dynamic/fake"
"gotest.tools/v3/assert"
"knative.dev/client/pkg/eventing/v1beta1"
"knative.dev/client/pkg/eventing/v1beta2"
"knative.dev/client/pkg/util"
)
func TestEventtypeDelete(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.DeleteEventtype(eventtypeName, nil)
out, err := executeEventtypeCommand(eventingClient, "delete", eventtypeName, "--namespace", testNs)
out, err := executeEventtypeCommand(eventingClient, dynamicClient, "delete", eventtypeName, "--namespace", testNs)
assert.NilError(t, err, "Eventtype should be deleted")
assert.Assert(t, util.ContainsAll(out, "Eventtype", eventtypeName, "successfully", "deleted", "namespace", testNs))
@ -40,12 +43,13 @@ func TestEventtypeDelete(t *testing.T) {
}
func TestEventtypeDeleteWithError(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, "default")
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.DeleteEventtype(eventtypeName, fmt.Errorf("mock-error"))
_, err := executeEventtypeCommand(eventingClient, "delete", eventtypeName)
_, err := executeEventtypeCommand(eventingClient, dynamicClient, "delete", eventtypeName)
assert.ErrorContains(t, err, "cannot delete eventtype")
assert.Assert(t, util.ContainsAll(err.Error(), "mock-error"))
@ -54,9 +58,10 @@ func TestEventtypeDeleteWithError(t *testing.T) {
}
func TestEventtypeDeleteWithNameMissingError(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, "default")
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
_, err := executeEventtypeCommand(eventingClient, "delete")
_, err := executeEventtypeCommand(eventingClient, dynamicClient, "delete")
assert.ErrorContains(t, err, "eventtype delete")
assert.Assert(t, util.ContainsAll(err.Error(), "eventtype", "delete", "requires", "name"))

16
pkg/kn/commands/eventtype/describe.go
View File

@ -24,7 +24,7 @@ import (
"github.com/spf13/cobra"
"k8s.io/cli-runtime/pkg/genericclioptions"
eventingv1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
"knative.dev/eventing/pkg/apis/eventing/v1beta2"
"knative.dev/client/pkg/kn/commands"
"knative.dev/client/pkg/printers"
@ -62,7 +62,7 @@ func NewEventtypeDescribeCommand(p *commands.KnParams) *cobra.Command {
return err
}
eventingV1Beta1Client, err := p.NewEventingV1beta1Client(namespace)
eventingV1Beta1Client, err := p.NewEventingV1beta2Client(namespace)
if err != nil {
return err
}
@ -91,7 +91,7 @@ func NewEventtypeDescribeCommand(p *commands.KnParams) *cobra.Command {
}
// describeEventtype prints eventtype details to the provided output writer
func describeEventtype(out io.Writer, eventtype *eventingv1beta1.EventType, printDetails bool) error {
func describeEventtype(out io.Writer, eventtype *v1beta2.EventType, printDetails bool) error {
var source string
if eventtype.Spec.Source != nil {
source = eventtype.Spec.Source.String()
@ -99,7 +99,15 @@ func describeEventtype(out io.Writer, eventtype *eventingv1beta1.EventType, prin
dw := printers.NewPrefixWriter(out)
commands.WriteMetadata(dw, &eventtype.ObjectMeta, printDetails)
dw.WriteAttribute("Source", source)
dw.WriteAttribute("Broker", eventtype.Spec.Broker)
refW := dw.WriteAttribute("Reference", "")
if eventtype.Spec.Reference != nil {
refW.WriteAttribute("APIVersion", eventtype.Spec.Reference.APIVersion)
refW.WriteAttribute("Kind", eventtype.Spec.Reference.Kind)
refW.WriteAttribute("Name", eventtype.Spec.Reference.Name)
if eventtype.Namespace != "" && eventtype.Namespace != eventtype.Spec.Reference.Namespace {
refW.WriteAttribute("Namespace", eventtype.Spec.Reference.Namespace)
}
}
dw.WriteLine()
dw.WriteLine()
commands.WriteConditions(dw, eventtype.Status.Conditions, printDetails)

52
pkg/kn/commands/eventtype/describe_test.go
View File

@ -21,30 +21,35 @@ import (
"fmt"
"testing"
dynamicfake "knative.dev/client/pkg/dynamic/fake"
eventingv1 "knative.dev/eventing/pkg/apis/eventing/v1"
"gotest.tools/v3/assert"
"gotest.tools/v3/assert/cmp"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"knative.dev/client/pkg/eventing/v1beta1"
"knative.dev/client/pkg/eventing/v1beta2"
"knative.dev/client/pkg/util"
eventingv1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
eventingv1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
"knative.dev/pkg/apis"
duckv1 "knative.dev/pkg/apis/duck/v1"
)
func TestEventtypeDescribe(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.GetEventtype(eventtypeName, getEventtype(eventtypeName, testNs), nil)
out, err := executeEventtypeCommand(eventingClient, "describe", eventtypeName, "--namespace", testNs)
out, err := executeEventtypeCommand(eventingClient, dynamicClient, "describe", eventtypeName, "--namespace", testNs)
assert.NilError(t, err)
assert.Assert(t, cmp.Regexp(fmt.Sprintf("Name:\\s+%s", eventtypeName), out))
assert.Assert(t, cmp.Regexp(fmt.Sprintf("Namespace:\\s+%s", testNs), out))
assert.Assert(t, cmp.Regexp(fmt.Sprintf("Source:\\s+%s", testSource), out))
assert.Assert(t, cmp.Regexp(fmt.Sprintf("Broker:\\s+%s", testBroker), out))
assert.Assert(t, cmp.Regexp("Reference:\\s+\n", out))
assert.Assert(t, cmp.Regexp(fmt.Sprintf("Name:\\s+%s", testBroker), out))
assert.Assert(t, util.ContainsAll(out, "Conditions:", "Ready", "BrokerReady", "BrokerExists"))
@ -52,11 +57,13 @@ func TestEventtypeDescribe(t *testing.T) {
}
func TestEventtypeDescribeError(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.GetEventtype(eventtypeName, getEventtype(eventtypeName, testNs), fmt.Errorf("mock-error"))
_, err := executeEventtypeCommand(eventingClient, "describe", eventtypeName, "--namespace", testNs)
_, err := executeEventtypeCommand(eventingClient, dynamicClient, "describe", eventtypeName, "--namespace", testNs)
assert.Error(t, err, "mock-error")
@ -64,15 +71,18 @@ func TestEventtypeDescribeError(t *testing.T) {
}
func TestEventtypeDescribeWithNameMissingWithError(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
_, err := executeEventtypeCommand(eventingClient, "describe", "--namespace", testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
_, err := executeEventtypeCommand(eventingClient, dynamicClient, "describe", "--namespace", testNs)
assert.ErrorContains(t, err, "eventtype describe")
assert.Assert(t, util.ContainsAll(err.Error(), "requires", "eventtype", "name"))
}
func TestEventtypeDescribeMachineReadable(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
@ -80,17 +90,17 @@ func TestEventtypeDescribeMachineReadable(t *testing.T) {
// json
eventingRecorder.GetEventtype(eventtypeName, eventtype, nil)
out, err := executeEventtypeCommand(eventingClient, "describe", eventtypeName, "--namespace", testNs, "-o", "json")
out, err := executeEventtypeCommand(eventingClient, dynamicClient, "describe", eventtypeName, "--namespace", testNs, "-o", "json")
assert.NilError(t, err)
result := &eventingv1beta1.EventType{}
result := &eventingv1beta2.EventType{}
err = json.Unmarshal([]byte(out), result)
assert.NilError(t, err)
assert.DeepEqual(t, eventtype, result)
// yaml
eventingRecorder.GetEventtype(eventtypeName, eventtype, nil)
out, err = executeEventtypeCommand(eventingClient, "describe", eventtypeName, "--namespace", testNs, "-o", "yaml")
out, err = executeEventtypeCommand(eventingClient, dynamicClient, "describe", eventtypeName, "--namespace", testNs, "-o", "yaml")
assert.NilError(t, err)
assert.Assert(t, util.ContainsAll(out, "kind: EventType", "spec:", "status:", "metadata:"))
@ -98,23 +108,27 @@ func TestEventtypeDescribeMachineReadable(t *testing.T) {
eventingRecorder.Validate()
}
func getEventtype(name string, ns string) *eventingv1beta1.EventType {
func getEventtype(name string, ns string) *eventingv1beta2.EventType {
source, _ := apis.ParseURL(testSource)
return &eventingv1beta1.EventType{
return &eventingv1beta2.EventType{
TypeMeta: metav1.TypeMeta{
Kind: "EventType",
APIVersion: eventingv1beta1.SchemeGroupVersion.String(),
APIVersion: eventingv1beta2.SchemeGroupVersion.String(),
},
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: ns,
},
Spec: eventingv1beta1.EventTypeSpec{
Spec: eventingv1beta2.EventTypeSpec{
Type: cetype,
Source: source,
Broker: testBroker,
Reference: &duckv1.KReference{
APIVersion: eventingv1.SchemeGroupVersion.String(),
Kind: "Broker",
Name: testBroker,
},
},
Status: eventingv1beta1.EventTypeStatus{
Status: eventingv1beta2.EventTypeStatus{
Status: duckv1.Status{
Conditions: duckv1.Conditions{
apis.Condition{

14
pkg/kn/commands/eventtype/eventtype.go
View File

@ -18,6 +18,7 @@ package eventtype
import (
"github.com/spf13/cobra"
"k8s.io/apimachinery/pkg/runtime/schema"
"knative.dev/client/pkg/kn/commands"
)
@ -35,3 +36,16 @@ func NewEventTypeCommand(p *commands.KnParams) *cobra.Command {
eventCmd.AddCommand(NewEventtypeDeleteCommand(p))
return eventCmd
}
var referenceMappings = map[string]schema.GroupVersionResource{
"broker": {
Resource: "brokers",
Group: "eventing.knative.dev",
Version: "v1",
},
"channel": {
Resource: "channels",
Group: "messaging.knative.dev",
Version: "v1",
},
}

26
pkg/kn/commands/eventtype/eventtype_test.go
View File

@ -19,10 +19,12 @@ package eventtype
import (
"bytes"
kndynamic "knative.dev/client/pkg/dynamic"
"k8s.io/client-go/tools/clientcmd"
"knative.dev/client/pkg/eventing/v1beta1"
"knative.dev/client/pkg/eventing/v1beta2"
"knative.dev/client/pkg/kn/commands"
eventingv1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
eventingv1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
"knative.dev/pkg/apis"
)
@ -60,19 +62,19 @@ current-context: x
}
}
func createEventtype(eventtypeName, ceType, namespace string) *eventingv1beta1.EventType {
return v1beta1.NewEventtypeBuilder(eventtypeName).Namespace(namespace).Type(ceType).Build()
func createEventtype(eventtypeName, ceType, namespace string) *eventingv1beta2.EventType {
return v1beta2.NewEventtypeBuilder(eventtypeName).Namespace(namespace).Type(ceType).Build()
}
func createEventtypeWithSource(eventtypeName, ceType, namespace string, source *apis.URL) *eventingv1beta1.EventType {
return v1beta1.NewEventtypeBuilder(eventtypeName).Namespace(namespace).Type(ceType).Source(source).Build()
func createEventtypeWithSource(eventtypeName, ceType, namespace string, source *apis.URL) *eventingv1beta2.EventType {
return v1beta2.NewEventtypeBuilder(eventtypeName).Namespace(namespace).Type(ceType).Source(source).Build()
}
func createEventtypeWithBroker(name, cetype, broker, namespace string) *eventingv1beta1.EventType {
return v1beta1.NewEventtypeBuilder(eventtypeName).Namespace(namespace).Type(cetype).Broker(broker).Build()
func createEventtypeWithBroker(name, cetype, broker, namespace string) *eventingv1beta2.EventType {
return v1beta2.NewEventtypeBuilder(eventtypeName).Namespace(namespace).Type(cetype).Broker(broker).Build()
}
func executeEventtypeCommand(client *v1beta1.MockKnEventingV1beta1Client, args ...string) (string, error) {
func executeEventtypeCommand(client *v1beta2.MockKnEventingV1beta2Client, dynamicClient kndynamic.KnDynamicClient, args ...string) (string, error) {
knParams := &commands.KnParams{}
knParams.ClientConfig = blankConfig
@ -80,10 +82,14 @@ func executeEventtypeCommand(client *v1beta1.MockKnEventingV1beta1Client, args .
output := new(bytes.Buffer)
knParams.Output = output
knParams.NewEventingV1beta1Client = func(namespace string) (v1beta1.KnEventingV1Beta1Client, error) {
knParams.NewEventingV1beta2Client = func(namespace string) (v1beta2.KnEventingV1Beta2Client, error) {
return client, nil
}
knParams.NewDynamicClient = func(namespace string) (kndynamic.KnDynamicClient, error) {
return dynamicClient, nil
}
cmd := NewEventTypeCommand(knParams)
cmd.SetArgs(args)
cmd.SetOut(output)

26
pkg/kn/commands/eventtype/list.go
View File

@ -20,14 +20,14 @@ import (
"fmt"
"github.com/spf13/cobra"
eventingv1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
metav1beta1 "k8s.io/apimachinery/pkg/apis/meta/v1beta1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"knative.dev/client/pkg/kn/commands"
"knative.dev/client/pkg/kn/commands/flags"
hprinters "knative.dev/client/pkg/printers"
eventingv1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
)
var listExample = `
@ -52,12 +52,12 @@ func NewEventtypeListCommand(p *commands.KnParams) *cobra.Command {
return err
}
eventingV1Beta1Client, err := p.NewEventingV1beta1Client(namespace)
eventingV1Beta2Client, err := p.NewEventingV1beta2Client(namespace)
if err != nil {
return err
}
eventTypeList, err := eventingV1Beta1Client.ListEventtypes(cmd.Context())
eventTypeList, err := eventingV1Beta2Client.ListEventtypes(cmd.Context())
if err != nil {
return err
}
@ -85,12 +85,12 @@ func NewEventtypeListCommand(p *commands.KnParams) *cobra.Command {
// ListHandlers handles printing human readable table for `kn eventtype list` command's output
func ListHandlers(h hprinters.PrintHandler) {
eventTypeColumnDefinitions := []metav1beta1.TableColumnDefinition{
eventTypeColumnDefinitions := []metav1.TableColumnDefinition{
{Name: "Namespace", Type: "string", Description: "Namespace of the EventType instance", Priority: 0},
{Name: "Name", Type: "string", Description: "Name of the EventType instance", Priority: 1},
{Name: "Type", Type: "string", Description: "Type of the EventType instance", Priority: 1},
{Name: "Source", Type: "string", Description: "Source of the EventType instance", Priority: 1},
{Name: "Broker", Type: "string", Description: "Broker of the EventType instance", Priority: 1},
{Name: "Reference", Type: "string", Description: "Reference of the EventType instance", Priority: 1},
{Name: "Age", Type: "string", Description: "Age of the EventType instance", Priority: 1},
{Name: "Ready", Type: "string", Description: "Ready state of the EventType instance", Priority: 1},
}
@ -99,8 +99,8 @@ func ListHandlers(h hprinters.PrintHandler) {
}
// printEventTypeList populates the eventtype list table rows
func printEventTypeList(eventTypeList *eventingv1beta1.EventTypeList, options hprinters.PrintOptions) ([]metav1beta1.TableRow, error) {
rows := make([]metav1beta1.TableRow, 0, len(eventTypeList.Items))
func printEventTypeList(eventTypeList *eventingv1beta2.EventTypeList, options hprinters.PrintOptions) ([]metav1.TableRow, error) {
rows := make([]metav1.TableRow, 0, len(eventTypeList.Items))
for i := range eventTypeList.Items {
eventType := &eventTypeList.Items[i]
@ -114,15 +114,15 @@ func printEventTypeList(eventTypeList *eventingv1beta1.EventTypeList, options hp
}
// printEventType populates the eventtype table rows
func printEventType(eventType *eventingv1beta1.EventType, options hprinters.PrintOptions) ([]metav1beta1.TableRow, error) {
func printEventType(eventType *eventingv1beta2.EventType, options hprinters.PrintOptions) ([]metav1.TableRow, error) {
name := eventType.Name
age := commands.TranslateTimestampSince(eventType.CreationTimestamp)
cetype := eventType.Spec.Type
source := eventType.Spec.Source
broker := eventType.Spec.Broker
reference := eventType.Spec.Reference.Name
ready := commands.ReadyCondition(eventType.Status.Conditions)
row := metav1beta1.TableRow{
row := metav1.TableRow{
Object: runtime.RawExtension{Object: eventType},
}
@ -130,6 +130,6 @@ func printEventType(eventType *eventingv1beta1.EventType, options hprinters.Prin
row.Cells = append(row.Cells, eventType.Namespace)
}
row.Cells = append(row.Cells, name, cetype, source, broker, age, ready)
return []metav1beta1.TableRow{row}, nil
row.Cells = append(row.Cells, name, cetype, source, reference, age, ready)
return []metav1.TableRow{row}, nil
}

32
pkg/kn/commands/eventtype/list_test.go
View File

@ -21,15 +21,18 @@ import (
"strings"
"testing"
dynamicfake "knative.dev/client/pkg/dynamic/fake"
"gotest.tools/v3/assert"
"knative.dev/client/pkg/eventing/v1beta1"
"knative.dev/client/pkg/eventing/v1beta2"
"knative.dev/client/pkg/util"
eventingv1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
eventingv1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
"knative.dev/eventing/pkg/client/clientset/versioned/scheme"
)
func TestEventtypeList(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
@ -37,18 +40,18 @@ func TestEventtypeList(t *testing.T) {
eventtype2 := getEventtype("foo2", testNs)
eventtype3 := getEventtype("foo3", testNs)
eventtypeList := &eventingv1beta1.EventTypeList{Items: []eventingv1beta1.EventType{*eventtype1, *eventtype2, *eventtype3}}
eventtypeList := &eventingv1beta2.EventTypeList{Items: []eventingv1beta2.EventType{*eventtype1, *eventtype2, *eventtype3}}
util.UpdateGroupVersionKindWithScheme(eventtypeList, eventingv1beta1.SchemeGroupVersion, scheme.Scheme)
util.UpdateGroupVersionKindWithScheme(eventtypeList, eventingv1beta2.SchemeGroupVersion, scheme.Scheme)
t.Run("default output", func(t *testing.T) {
eventingRecorder.ListEventtypes(eventtypeList, nil)
output, err := executeEventtypeCommand(eventingClient, "list")
output, err := executeEventtypeCommand(eventingClient, dynamicClient, "list")
assert.NilError(t, err)
outputLines := strings.Split(output, "\n")
assert.Check(t, util.ContainsAll(outputLines[0], "NAME", "T", "SOURCE", "BROKER", "AGE", "READY"))
assert.Check(t, util.ContainsAll(outputLines[0], "NAME", "T", "SOURCE", "REFERENCE", "AGE", "READY"))
assert.Check(t, util.ContainsAll(outputLines[1], "foo1", cetype, testBroker, testSource, "True"))
assert.Check(t, util.ContainsAll(outputLines[2], "foo2", cetype, testBroker, testSource, "True"))
assert.Check(t, util.ContainsAll(outputLines[3], "foo3", cetype, testBroker, testSource, "True"))
@ -59,10 +62,10 @@ func TestEventtypeList(t *testing.T) {
t.Run("json format output", func(t *testing.T) {
eventingRecorder.ListEventtypes(eventtypeList, nil)
output, err := executeEventtypeCommand(eventingClient, "list", "-o", "json")
output, err := executeEventtypeCommand(eventingClient, dynamicClient, "list", "-o", "json")
assert.NilError(t, err)
result := eventingv1beta1.EventTypeList{}
result := eventingv1beta2.EventTypeList{}
err = json.Unmarshal([]byte(output), &result)
assert.NilError(t, err)
assert.DeepEqual(t, eventtypeList.Items, result.Items)
@ -73,11 +76,11 @@ func TestEventtypeList(t *testing.T) {
t.Run("all namespaces", func(t *testing.T) {
eventingRecorder.ListEventtypes(eventtypeList, nil)
output, err := executeEventtypeCommand(eventingClient, "list", "--all-namespaces")
output, err := executeEventtypeCommand(eventingClient, dynamicClient, "list", "--all-namespaces")
assert.NilError(t, err)
outputLines := strings.Split(output, "\n")
assert.Check(t, util.ContainsAll(outputLines[0], "NAMESPACE", "NAME", "T", "SOURCE", "BROKER", "AGE", "READY"))
assert.Check(t, util.ContainsAll(outputLines[0], "NAMESPACE", "NAME", "T", "SOURCE", "REFERENCE", "AGE", "READY"))
assert.Check(t, util.ContainsAll(outputLines[1], "foo1", testNs, cetype, testBroker, testSource, "True"))
assert.Check(t, util.ContainsAll(outputLines[2], "foo2", testNs, cetype, testBroker, testSource, "True"))
assert.Check(t, util.ContainsAll(outputLines[3], "foo3", testNs, cetype, testBroker, testSource, "True"))
@ -87,12 +90,13 @@ func TestEventtypeList(t *testing.T) {
}
func TestEventtypeListEmpty(t *testing.T) {
eventingClient := v1beta1.NewMockKnEventingV1beta1Client(t, testNs)
eventingClient := v1beta2.NewMockKnEventingV1beta2Client(t, testNs)
dynamicClient := dynamicfake.CreateFakeKnDynamicClient(testNs)
eventingRecorder := eventingClient.Recorder()
eventingRecorder.ListEventtypes(&eventingv1beta1.EventTypeList{}, nil)
output, err := executeEventtypeCommand(eventingClient, "list")
eventingRecorder.ListEventtypes(&eventingv1beta2.EventTypeList{}, nil)
output, err := executeEventtypeCommand(eventingClient, dynamicClient, "list")
assert.NilError(t, err)
assert.Assert(t, util.ContainsAll(output, "No", "eventtypes", "found"))

2
pkg/kn/commands/flags/eventtype.go
View File

@ -25,6 +25,6 @@ type EventtypeFlags struct {
func (e *EventtypeFlags) Add(cmd *cobra.Command) {
cmd.Flags().StringVarP(&e.Type, "type", "t", "", "Cloud Event type")
cmd.Flags().StringVar(&e.Source, "source", "", "Cloud Event source")
cmd.Flags().StringVarP(&e.Broker, "broker", "b", "", "Cloud Event broker")
cmd.Flags().StringVarP(&e.Broker, "broker", "b", "", "Cloud Event Broker")
cmd.MarkFlagRequired("type")
}

70
pkg/kn/commands/flags/sink.go
View File

@ -30,31 +30,42 @@ import (
)
type SinkFlags struct {
sink string
Sink string
SinkMappings map[string]schema.GroupVersionResource
}
// AddWithFlagName configures sink flag with given flag name and a short flag name
// pass empty short flag name if you dont want to set one
// NewSinkFlag is a constructor function to create SinkFlags from provided map
func NewSinkFlag(mapping map[string]schema.GroupVersionResource) *SinkFlags {
return &SinkFlags{
SinkMappings: mapping,
}
}
// AddWithFlagName configures Sink flag with given flag name and a short flag name
// pass empty short flag name if you don't want to set one
func (i *SinkFlags) AddWithFlagName(cmd *cobra.Command, fname, short string) {
flag := "--" + fname
if short == "" {
cmd.Flags().StringVar(&i.sink, fname, "", "")
cmd.Flags().StringVar(&i.Sink, fname, "", "")
} else {
cmd.Flags().StringVarP(&i.sink, fname, short, "", "")
cmd.Flags().StringVarP(&i.Sink, fname, short, "", "")
}
cmd.Flag(fname).Usage = "Addressable sink for events. " +
"You can specify a broker, channel, Knative service or URI. " +
"Examples: '" + flag + " broker:nest' for a broker 'nest', " +
"'" + flag + " channel:pipe' for a channel 'pipe', " +
"'" + flag + " ksvc:mysvc:mynamespace' for a Knative service 'mysvc' in another namespace 'mynamespace', " +
"'" + flag + " https://event.receiver.uri' for an URI with an 'http://' or 'https://' schema, " +
"'" + flag + " https://event.receiver.uri' for an HTTP URI, " +
"'" + flag + " ksvc:receiver' or simply '" + flag + " receiver' for a Knative service 'receiver' in the current namespace. " +
"If a prefix is not provided, it is considered as a Knative service in the current namespace. " +
"If referring to a Knative service in another namespace, 'ksvc:name:namespace' combination must be provided explicitly."
"'" + flag + " special.eventing.dev/v1alpha1/channels:pipe' for GroupVersionResource of v1alpha1 'pipe'. " +
"If a prefix is not provided, it is considered as a Knative service in the current namespace."
// Use default mapping if empty
if i.SinkMappings == nil {
i.SinkMappings = defaultSinkMappings
}
for _, p := range config.GlobalConfig.SinkMappings() {
//user configuration might override the default configuration
sinkMappings[p.Prefix] = schema.GroupVersionResource{
i.SinkMappings[p.Prefix] = schema.GroupVersionResource{
Resource: p.Resource,
Group: p.Group,
Version: p.Version,
@ -62,13 +73,13 @@ func (i *SinkFlags) AddWithFlagName(cmd *cobra.Command, fname, short string) {
}
}
// Add configures sink flag with name 'sink' amd short name 's'
// Add configures Sink flag with name 'Sink' amd short name 's'
func (i *SinkFlags) Add(cmd *cobra.Command) {
i.AddWithFlagName(cmd, "sink", "s")
}
// sinkPrefixes maps prefixes used for sinks to their GroupVersionResources.
var sinkMappings = map[string]schema.GroupVersionResource{
// SinkPrefixes maps prefixes used for sinks to their GroupVersionResources.
var defaultSinkMappings = map[string]schema.GroupVersionResource{
"broker": {
Resource: "brokers",
Group: "eventing.knative.dev",
@ -91,10 +102,14 @@ var sinkMappings = map[string]schema.GroupVersionResource{
// It validates that any object the user is referring to exists.
func (i *SinkFlags) ResolveSink(ctx context.Context, knclient clientdynamic.KnDynamicClient, namespace string) (*duckv1.Destination, error) {
client := knclient.RawClient()
if i.sink == "" {
if i.Sink == "" {
return nil, nil
}
prefix, name, ns := parseSink(i.sink)
// Use default mapping if empty
if i.SinkMappings == nil {
i.SinkMappings = defaultSinkMappings
}
prefix, name, ns := parseSink(i.Sink)
if prefix == "" {
// URI target
uri, err := apis.ParseURL(name)
@ -103,10 +118,10 @@ func (i *SinkFlags) ResolveSink(ctx context.Context, knclient clientdynamic.KnDy
}
return &duckv1.Destination{URI: uri}, nil
}
typ, ok := sinkMappings[prefix]
gvr, ok := i.SinkMappings[prefix]
if !ok {
if prefix == "svc" || prefix == "service" {
return nil, fmt.Errorf("unsupported sink prefix: '%s', please use prefix 'ksvc' for knative service", prefix)
return nil, fmt.Errorf("unsupported Sink prefix: '%s', please use prefix 'ksvc' for knative service", prefix)
}
idx := strings.LastIndex(prefix, "/")
var groupVersion string
@ -116,21 +131,24 @@ func (i *SinkFlags) ResolveSink(ctx context.Context, knclient clientdynamic.KnDy
} else {
kind = prefix
}
parsedVersion, _ := schema.ParseGroupVersion(groupVersion)
parsedVersion, err := schema.ParseGroupVersion(groupVersion)
if err != nil {
return nil, err
}
// For the RAWclient the resource name must be in lower case plural form.
// This is the best effort to sanitize the inputs, but the safest way is to provide
// the appropriate form in user's input.
if !strings.HasSuffix(kind, "s") {
kind = kind + "s"
}
typ = schema.GroupVersionResource{
Group: parsedVersion.Group,
Version: parsedVersion.Version,
Resource: kind,
}
kind = strings.ToLower(kind)
gvr = parsedVersion.WithResource(kind)
}
if ns != "" {
namespace = ns
}
obj, err := client.Resource(typ).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})
obj, err := client.Resource(gvr).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})
if err != nil {
return nil, err
}
@ -163,10 +181,10 @@ func parseSink(sink string) (string, string, string) {
}
}
// SinkToString prepares a sink for list output
// SinkToString prepares a Sink for list output
func SinkToString(sink duckv1.Destination) string {
if sink.Ref != nil {
if sink.Ref.Kind == "Service" && strings.HasPrefix(sink.Ref.APIVersion, sinkMappings["ksvc"].Group) {
if sink.Ref.Kind == "Service" && strings.HasPrefix(sink.Ref.APIVersion, defaultSinkMappings["ksvc"].Group) {
return fmt.Sprintf("ksvc:%s", sink.Ref.Name)
} else {
return fmt.Sprintf("%s:%s", strings.ToLower(sink.Ref.Kind), sink.Ref.Name)

18
pkg/kn/commands/flags/sink_test.go
View File

@ -58,7 +58,7 @@ func TestSinkFlagAdd(t *testing.T) {
}
for _, tc := range cases {
c := &cobra.Command{Use: "sinktest"}
sinkFlags := new(SinkFlags)
sinkFlags := SinkFlags{}
if tc.flagName == "" {
sinkFlags.Add(c)
assert.Equal(t, tc.expectedFlagName, c.Flag("sink").Name)
@ -130,6 +130,18 @@ func TestResolve(t *testing.T) {
Namespace: "default",
Name: "foo",
}}, ""},
{"sources.knative.dev/v1/Pingsource:foo", &duckv1.Destination{Ref: &duckv1.KReference{
APIVersion: "sources.knative.dev/v1",
Kind: "PingSource",
Namespace: "default",
Name: "foo",
}}, ""},
{"sources.knative.dev/v1/PingSources:foo", &duckv1.Destination{Ref: &duckv1.KReference{
APIVersion: "sources.knative.dev/v1",
Kind: "PingSource",
Namespace: "default",
Name: "foo",
}}, ""},
{"http://target.example.com", &duckv1.Destination{
URI: targetExampleCom,
}, ""},
@ -141,7 +153,7 @@ func TestResolve(t *testing.T) {
dynamicClient := dynamicfake.CreateFakeKnDynamicClient("default", mysvc, defaultBroker, pipeChannel, pingSource)
for _, c := range cases {
i := &SinkFlags{c.sink}
i := &SinkFlags{Sink: c.sink}
result, err := i.ResolveSink(context.Background(), dynamicClient, "default")
if c.destination != nil {
assert.DeepEqual(t, result, c.destination)
@ -185,7 +197,7 @@ func TestResolveWithNamespace(t *testing.T) {
}
dynamicClient := dynamicfake.CreateFakeKnDynamicClient("my-namespace", mysvc, defaultBroker, pipeChannel)
for _, c := range cases {
i := &SinkFlags{c.sink}
i := &SinkFlags{Sink: c.sink}
result, err := i.ResolveSink(context.Background(), dynamicClient, "default")
if c.destination != nil {
assert.DeepEqual(t, result, c.destination)

16
pkg/kn/commands/types.go
View File

@ -26,7 +26,7 @@ import (
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
eventingv1 "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1"
eventingv1beta1 "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1"
eventingv1beta2 "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2"
messagingv1 "knative.dev/eventing/pkg/client/clientset/versioned/typed/messaging/v1"
sourcesv1client "knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1"
sourcesv1beta2client "knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1beta2"
@ -38,7 +38,7 @@ import (
clientdynamic "knative.dev/client/pkg/dynamic"
knerrors "knative.dev/client/pkg/errors"
clienteventingv1 "knative.dev/client/pkg/eventing/v1"
clienteventingv1beta1 "knative.dev/client/pkg/eventing/v1beta1"
clienteventingv1beta2 "knative.dev/client/pkg/eventing/v1beta2"
clientmessagingv1 "knative.dev/client/pkg/messaging/v1"
clientservingv1 "knative.dev/client/pkg/serving/v1"
clientservingv1alpha1 "knative.dev/client/pkg/serving/v1alpha1"
@ -65,7 +65,7 @@ type KnParams struct {
NewEventingClient func(namespace string) (clienteventingv1.KnEventingClient, error)
NewMessagingClient func(namespace string) (clientmessagingv1.KnMessagingClient, error)
NewDynamicClient func(namespace string) (clientdynamic.KnDynamicClient, error)
NewEventingV1beta1Client func(namespace string) (clienteventingv1beta1.KnEventingV1Beta1Client, error)
NewEventingV1beta2Client func(namespace string) (clienteventingv1beta2.KnEventingV1Beta2Client, error)
// General global options
LogHTTP bool
@ -111,8 +111,8 @@ func (params *KnParams) Initialize() {
params.NewSourcesV1beta2Client = params.newSourcesClientV1beta2
}
if params.NewEventingV1beta1Client == nil {
params.NewEventingV1beta1Client = params.newEventingV1Beta1Client
if params.NewEventingV1beta2Client == nil {
params.NewEventingV1beta2Client = params.newEventingV1Beta2Client
}
}
@ -190,14 +190,14 @@ func (params *KnParams) newEventingClient(namespace string) (clienteventingv1.Kn
return clienteventingv1.NewKnEventingClient(client, namespace), nil
}
func (params *KnParams) newEventingV1Beta1Client(namespace string) (clienteventingv1beta1.KnEventingV1Beta1Client, error) {
func (params *KnParams) newEventingV1Beta2Client(namespace string) (clienteventingv1beta2.KnEventingV1Beta2Client, error) {
restConfig, err := params.RestConfig()
if err != nil {
return nil, err
}
client, _ := eventingv1beta1.NewForConfig(restConfig)
return clienteventingv1beta1.NewKnEventingV1Beta1Client(client, namespace), nil
client, _ := eventingv1beta2.NewForConfig(restConfig)
return clienteventingv1beta2.NewKnEventingV1Beta2Client(client, namespace), nil
}
func (params *KnParams) newMessagingClient(namespace string) (clientmessagingv1.KnMessagingClient, error) {

4
pkg/kn/commands/types_test.go
View File

@ -513,7 +513,7 @@ func TestInitialize(t *testing.T) {
assert.Assert(t, params.NewEventingClient != nil)
assert.Assert(t, params.NewMessagingClient != nil)
assert.Assert(t, params.NewDynamicClient != nil)
assert.Assert(t, params.NewEventingV1beta1Client != nil)
assert.Assert(t, params.NewEventingV1beta2Client != nil)
basic, err := clientcmd.NewClientConfigFromBytes([]byte(BASIC_KUBECONFIG))
if err != nil {
@ -542,7 +542,7 @@ func TestInitialize(t *testing.T) {
assert.NilError(t, err)
assert.Assert(t, sourcesClient != nil)
eventingBeta1Client, err := params.NewEventingV1beta1Client("mockNamespace")
eventingBeta1Client, err := params.NewEventingV1beta2Client("mockNamespace")
assert.NilError(t, err)
assert.Assert(t, eventingBeta1Client != nil)
}

5
test/e2e/eventtype_test.go
View File

@ -18,6 +18,7 @@
package e2e
import (
"os"
"testing"
"gotest.tools/v3/assert"
@ -37,6 +38,10 @@ const (
)
func TestEventtype(t *testing.T) {
//FIXME: enable after Eventing v1.11 is out
if os.Getenv("LATEST_RELEASE") == "true" {
t.Skip("The tests are skipped on Eventing v1.10")
}
t.Parallel()
it, err := test.NewKnTest()
assert.NilError(t, err)

2
vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/doc.go → vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/doc.go vendored
View File

@ -17,4 +17,4 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
// This package has the automatically generated typed clients.
package v1beta1
package v1beta2

36
vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/eventing_client.go → vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/eventing_client.go vendored
View File

@ -16,34 +16,34 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta1
package v1beta2
import (
"net/http"
rest "k8s.io/client-go/rest"
v1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
v1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
"knative.dev/eventing/pkg/client/clientset/versioned/scheme"
)
type EventingV1beta1Interface interface {
type EventingV1beta2Interface interface {
RESTClient() rest.Interface
EventTypesGetter
}
// EventingV1beta1Client is used to interact with features provided by the eventing.knative.dev group.
type EventingV1beta1Client struct {
// EventingV1beta2Client is used to interact with features provided by the eventing.knative.dev group.
type EventingV1beta2Client struct {
restClient rest.Interface
}
func (c *EventingV1beta1Client) EventTypes(namespace string) EventTypeInterface {
func (c *EventingV1beta2Client) EventTypes(namespace string) EventTypeInterface {
return newEventTypes(c, namespace)
}
// NewForConfig creates a new EventingV1beta1Client for the given config.
// NewForConfig creates a new EventingV1beta2Client for the given config.
// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient),
// where httpClient was generated with rest.HTTPClientFor(c).
func NewForConfig(c *rest.Config) (*EventingV1beta1Client, error) {
func NewForConfig(c *rest.Config) (*EventingV1beta2Client, error) {
config := *c
if err := setConfigDefaults(&config); err != nil {
return nil, err
@ -55,9 +55,9 @@ func NewForConfig(c *rest.Config) (*EventingV1beta1Client, error) {
return NewForConfigAndClient(&config, httpClient)
}
// NewForConfigAndClient creates a new EventingV1beta1Client for the given config and http client.
// NewForConfigAndClient creates a new EventingV1beta2Client for the given config and http client.
// Note the http client provided takes precedence over the configured transport values.
func NewForConfigAndClient(c *rest.Config, h *http.Client) (*EventingV1beta1Client, error) {
func NewForConfigAndClient(c *rest.Config, h *http.Client) (*EventingV1beta2Client, error) {
config := *c
if err := setConfigDefaults(&config); err != nil {
return nil, err
@ -66,12 +66,12 @@ func NewForConfigAndClient(c *rest.Config, h *http.Client) (*EventingV1beta1Clie
if err != nil {
return nil, err
}
return &EventingV1beta1Client{client}, nil
return &EventingV1beta2Client{client}, nil
}
// NewForConfigOrDie creates a new EventingV1beta1Client for the given config and
// NewForConfigOrDie creates a new EventingV1beta2Client for the given config and
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *EventingV1beta1Client {
func NewForConfigOrDie(c *rest.Config) *EventingV1beta2Client {
client, err := NewForConfig(c)
if err != nil {
panic(err)
@ -79,13 +79,13 @@ func NewForConfigOrDie(c *rest.Config) *EventingV1beta1Client {
return client
}
// New creates a new EventingV1beta1Client for the given RESTClient.
func New(c rest.Interface) *EventingV1beta1Client {
return &EventingV1beta1Client{c}
// New creates a new EventingV1beta2Client for the given RESTClient.
func New(c rest.Interface) *EventingV1beta2Client {
return &EventingV1beta2Client{c}
}
func setConfigDefaults(config *rest.Config) error {
gv := v1beta1.SchemeGroupVersion
gv := v1beta2.SchemeGroupVersion
config.GroupVersion = &gv
config.APIPath = "/apis"
config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
@ -99,7 +99,7 @@ func setConfigDefaults(config *rest.Config) error {
// RESTClient returns a RESTClient that is used to communicate
// with API server by this client implementation.
func (c *EventingV1beta1Client) RESTClient() rest.Interface {
func (c *EventingV1beta2Client) RESTClient() rest.Interface {
if c == nil {
return nil
}

42
vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/eventtype.go → vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/eventtype.go vendored
View File

@ -16,7 +16,7 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta1
package v1beta2
import (
"context"
@ -26,7 +26,7 @@ import (
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
rest "k8s.io/client-go/rest"
v1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
v1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
scheme "knative.dev/eventing/pkg/client/clientset/versioned/scheme"
)
@ -38,15 +38,15 @@ type EventTypesGetter interface {
// EventTypeInterface has methods to work with EventType resources.
type EventTypeInterface interface {
Create(ctx context.Context, eventType *v1beta1.EventType, opts v1.CreateOptions) (*v1beta1.EventType, error)
Update(ctx context.Context, eventType *v1beta1.EventType, opts v1.UpdateOptions) (*v1beta1.EventType, error)
UpdateStatus(ctx context.Context, eventType *v1beta1.EventType, opts v1.UpdateOptions) (*v1beta1.EventType, error)
Create(ctx context.Context, eventType *v1beta2.EventType, opts v1.CreateOptions) (*v1beta2.EventType, error)
Update(ctx context.Context, eventType *v1beta2.EventType, opts v1.UpdateOptions) (*v1beta2.EventType, error)
UpdateStatus(ctx context.Context, eventType *v1beta2.EventType, opts v1.UpdateOptions) (*v1beta2.EventType, error)
Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.EventType, error)
List(ctx context.Context, opts v1.ListOptions) (*v1beta1.EventTypeList, error)
Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta2.EventType, error)
List(ctx context.Context, opts v1.ListOptions) (*v1beta2.EventTypeList, error)
Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta1.EventType, err error)
Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta2.EventType, err error)
EventTypeExpansion
}
@ -57,7 +57,7 @@ type eventTypes struct {
}
// newEventTypes returns a EventTypes
func newEventTypes(c *EventingV1beta1Client, namespace string) *eventTypes {
func newEventTypes(c *EventingV1beta2Client, namespace string) *eventTypes {
return &eventTypes{
client: c.RESTClient(),
ns: namespace,
@ -65,8 +65,8 @@ func newEventTypes(c *EventingV1beta1Client, namespace string) *eventTypes {
}
// Get takes name of the eventType, and returns the corresponding eventType object, and an error if there is any.
func (c *eventTypes) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta1.EventType, err error) {
result = &v1beta1.EventType{}
func (c *eventTypes) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta2.EventType, err error) {
result = &v1beta2.EventType{}
err = c.client.Get().
Namespace(c.ns).
Resource("eventtypes").
@ -78,12 +78,12 @@ func (c *eventTypes) Get(ctx context.Context, name string, options v1.GetOptions
}
// List takes label and field selectors, and returns the list of EventTypes that match those selectors.
func (c *eventTypes) List(ctx context.Context, opts v1.ListOptions) (result *v1beta1.EventTypeList, err error) {
func (c *eventTypes) List(ctx context.Context, opts v1.ListOptions) (result *v1beta2.EventTypeList, err error) {
var timeout time.Duration
if opts.TimeoutSeconds != nil {
timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
}
result = &v1beta1.EventTypeList{}
result = &v1beta2.EventTypeList{}
err = c.client.Get().
Namespace(c.ns).
Resource("eventtypes").
@ -110,8 +110,8 @@ func (c *eventTypes) Watch(ctx context.Context, opts v1.ListOptions) (watch.Inte
}
// Create takes the representation of a eventType and creates it. Returns the server's representation of the eventType, and an error, if there is any.
func (c *eventTypes) Create(ctx context.Context, eventType *v1beta1.EventType, opts v1.CreateOptions) (result *v1beta1.EventType, err error) {
result = &v1beta1.EventType{}
func (c *eventTypes) Create(ctx context.Context, eventType *v1beta2.EventType, opts v1.CreateOptions) (result *v1beta2.EventType, err error) {
result = &v1beta2.EventType{}
err = c.client.Post().
Namespace(c.ns).
Resource("eventtypes").
@ -123,8 +123,8 @@ func (c *eventTypes) Create(ctx context.Context, eventType *v1beta1.EventType, o
}
// Update takes the representation of a eventType and updates it. Returns the server's representation of the eventType, and an error, if there is any.
func (c *eventTypes) Update(ctx context.Context, eventType *v1beta1.EventType, opts v1.UpdateOptions) (result *v1beta1.EventType, err error) {
result = &v1beta1.EventType{}
func (c *eventTypes) Update(ctx context.Context, eventType *v1beta2.EventType, opts v1.UpdateOptions) (result *v1beta2.EventType, err error) {
result = &v1beta2.EventType{}
err = c.client.Put().
Namespace(c.ns).
Resource("eventtypes").
@ -138,8 +138,8 @@ func (c *eventTypes) Update(ctx context.Context, eventType *v1beta1.EventType, o
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *eventTypes) UpdateStatus(ctx context.Context, eventType *v1beta1.EventType, opts v1.UpdateOptions) (result *v1beta1.EventType, err error) {
result = &v1beta1.EventType{}
func (c *eventTypes) UpdateStatus(ctx context.Context, eventType *v1beta2.EventType, opts v1.UpdateOptions) (result *v1beta2.EventType, err error) {
result = &v1beta2.EventType{}
err = c.client.Put().
Namespace(c.ns).
Resource("eventtypes").
@ -180,8 +180,8 @@ func (c *eventTypes) DeleteCollection(ctx context.Context, opts v1.DeleteOptions
}
// Patch applies the patch and returns the patched eventType.
func (c *eventTypes) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta1.EventType, err error) {
result = &v1beta1.EventType{}
func (c *eventTypes) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta2.EventType, err error) {
result = &v1beta2.EventType{}
err = c.client.Patch(pt).
Namespace(c.ns).
Resource("eventtypes").

0
vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/fake/doc.go → vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/fake/doc.go vendored
View File

8
vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/fake/fake_eventing_client.go → vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/fake/fake_eventing_client.go vendored
View File

@ -21,20 +21,20 @@ package fake
import (
rest "k8s.io/client-go/rest"
testing "k8s.io/client-go/testing"
v1beta1 "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1"
v1beta2 "knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2"
)
type FakeEventingV1beta1 struct {
type FakeEventingV1beta2 struct {
*testing.Fake
}
func (c *FakeEventingV1beta1) EventTypes(namespace string) v1beta1.EventTypeInterface {
func (c *FakeEventingV1beta2) EventTypes(namespace string) v1beta2.EventTypeInterface {
return &FakeEventTypes{c, namespace}
}
// RESTClient returns a RESTClient that is used to communicate
// with API server by this client implementation.
func (c *FakeEventingV1beta1) RESTClient() rest.Interface {
func (c *FakeEventingV1beta2) RESTClient() rest.Interface {
var ret *rest.RESTClient
return ret
}

50
vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/fake/fake_eventtype.go → vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/fake/fake_eventtype.go vendored
View File

@ -27,34 +27,34 @@ import (
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
testing "k8s.io/client-go/testing"
v1beta1 "knative.dev/eventing/pkg/apis/eventing/v1beta1"
v1beta2 "knative.dev/eventing/pkg/apis/eventing/v1beta2"
)
// FakeEventTypes implements EventTypeInterface
type FakeEventTypes struct {
Fake *FakeEventingV1beta1
Fake *FakeEventingV1beta2
ns string
}
var eventtypesResource = schema.GroupVersionResource{Group: "eventing.knative.dev", Version: "v1beta1", Resource: "eventtypes"}
var eventtypesResource = schema.GroupVersionResource{Group: "eventing.knative.dev", Version: "v1beta2", Resource: "eventtypes"}
var eventtypesKind = schema.GroupVersionKind{Group: "eventing.knative.dev", Version: "v1beta1", Kind: "EventType"}
var eventtypesKind = schema.GroupVersionKind{Group: "eventing.knative.dev", Version: "v1beta2", Kind: "EventType"}
// Get takes name of the eventType, and returns the corresponding eventType object, and an error if there is any.
func (c *FakeEventTypes) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta1.EventType, err error) {
func (c *FakeEventTypes) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta2.EventType, err error) {
obj, err := c.Fake.
Invokes(testing.NewGetAction(eventtypesResource, c.ns, name), &v1beta1.EventType{})
Invokes(testing.NewGetAction(eventtypesResource, c.ns, name), &v1beta2.EventType{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.EventType), err
return obj.(*v1beta2.EventType), err
}
// List takes label and field selectors, and returns the list of EventTypes that match those selectors.
func (c *FakeEventTypes) List(ctx context.Context, opts v1.ListOptions) (result *v1beta1.EventTypeList, err error) {
func (c *FakeEventTypes) List(ctx context.Context, opts v1.ListOptions) (result *v1beta2.EventTypeList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(eventtypesResource, eventtypesKind, c.ns, opts), &v1beta1.EventTypeList{})
Invokes(testing.NewListAction(eventtypesResource, eventtypesKind, c.ns, opts), &v1beta2.EventTypeList{})
if obj == nil {
return nil, err
@ -64,8 +64,8 @@ func (c *FakeEventTypes) List(ctx context.Context, opts v1.ListOptions) (result
if label == nil {
label = labels.Everything()
}
list := &v1beta1.EventTypeList{ListMeta: obj.(*v1beta1.EventTypeList).ListMeta}
for _, item := range obj.(*v1beta1.EventTypeList).Items {
list := &v1beta2.EventTypeList{ListMeta: obj.(*v1beta2.EventTypeList).ListMeta}
for _, item := range obj.(*v1beta2.EventTypeList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
@ -81,43 +81,43 @@ func (c *FakeEventTypes) Watch(ctx context.Context, opts v1.ListOptions) (watch.
}
// Create takes the representation of a eventType and creates it. Returns the server's representation of the eventType, and an error, if there is any.
func (c *FakeEventTypes) Create(ctx context.Context, eventType *v1beta1.EventType, opts v1.CreateOptions) (result *v1beta1.EventType, err error) {
func (c *FakeEventTypes) Create(ctx context.Context, eventType *v1beta2.EventType, opts v1.CreateOptions) (result *v1beta2.EventType, err error) {
obj, err := c.Fake.
Invokes(testing.NewCreateAction(eventtypesResource, c.ns, eventType), &v1beta1.EventType{})
Invokes(testing.NewCreateAction(eventtypesResource, c.ns, eventType), &v1beta2.EventType{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.EventType), err
return obj.(*v1beta2.EventType), err
}
// Update takes the representation of a eventType and updates it. Returns the server's representation of the eventType, and an error, if there is any.
func (c *FakeEventTypes) Update(ctx context.Context, eventType *v1beta1.EventType, opts v1.UpdateOptions) (result *v1beta1.EventType, err error) {
func (c *FakeEventTypes) Update(ctx context.Context, eventType *v1beta2.EventType, opts v1.UpdateOptions) (result *v1beta2.EventType, err error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateAction(eventtypesResource, c.ns, eventType), &v1beta1.EventType{})
Invokes(testing.NewUpdateAction(eventtypesResource, c.ns, eventType), &v1beta2.EventType{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.EventType), err
return obj.(*v1beta2.EventType), 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 *FakeEventTypes) UpdateStatus(ctx context.Context, eventType *v1beta1.EventType, opts v1.UpdateOptions) (*v1beta1.EventType, error) {
func (c *FakeEventTypes) UpdateStatus(ctx context.Context, eventType *v1beta2.EventType, opts v1.UpdateOptions) (*v1beta2.EventType, error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateSubresourceAction(eventtypesResource, "status", c.ns, eventType), &v1beta1.EventType{})
Invokes(testing.NewUpdateSubresourceAction(eventtypesResource, "status", c.ns, eventType), &v1beta2.EventType{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.EventType), err
return obj.(*v1beta2.EventType), err
}
// Delete takes name of the eventType and deletes it. Returns an error if one occurs.
func (c *FakeEventTypes) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteActionWithOptions(eventtypesResource, c.ns, name, opts), &v1beta1.EventType{})
Invokes(testing.NewDeleteActionWithOptions(eventtypesResource, c.ns, name, opts), &v1beta2.EventType{})
return err
}
@ -126,17 +126,17 @@ func (c *FakeEventTypes) Delete(ctx context.Context, name string, opts v1.Delete
func (c *FakeEventTypes) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
action := testing.NewDeleteCollectionAction(eventtypesResource, c.ns, listOpts)
_, err := c.Fake.Invokes(action, &v1beta1.EventTypeList{})
_, err := c.Fake.Invokes(action, &v1beta2.EventTypeList{})
return err
}
// Patch applies the patch and returns the patched eventType.
func (c *FakeEventTypes) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta1.EventType, err error) {
func (c *FakeEventTypes) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta2.EventType, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(eventtypesResource, c.ns, name, pt, data, subresources...), &v1beta1.EventType{})
Invokes(testing.NewPatchSubresourceAction(eventtypesResource, c.ns, name, pt, data, subresources...), &v1beta2.EventType{})
if obj == nil {
return nil, err
}
return obj.(*v1beta1.EventType), err
return obj.(*v1beta2.EventType), err
}

2
vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/generated_expansion.go → vendor/knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/generated_expansion.go vendored
View File

@ -16,6 +16,6 @@ limitations under the License.
// Code generated by client-gen. DO NOT EDIT.
package v1beta1
package v1beta2
type EventTypeExpansion interface{}

4
vendor/modules.txt vendored
View File

@ -963,8 +963,8 @@ knative.dev/eventing/pkg/apis/sources/v1beta2
knative.dev/eventing/pkg/client/clientset/versioned/scheme
knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1
knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1/fake
knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1
knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta1/fake
knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2
knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1beta2/fake
knative.dev/eventing/pkg/client/clientset/versioned/typed/messaging/v1
knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1
knative.dev/eventing/pkg/client/clientset/versioned/typed/sources/v1/fake