Adding class option to broker create

CHANGELOG.adoc

@@ -17,6 +17,10 @@
 |===
 | | Description | PR
 
+| 🎁
+| Adding --class flag to broker create command
+| https://github.com/knative/client/pull/1402[#1402]
+
 | 🎁
 | Add an `client.knative.dev/updateTimestamp` annotation to trigger a new revision when required
 | https://github.com/knative/client/pull/1364[#1364]

docs/cmd/kn_broker_create.md

@@ -13,13 +13,15 @@ kn broker create NAME
   # Create a broker 'mybroker' in the current namespace
   kn broker create mybroker
 
-  # Create a broker 'mybroker' in the 'myproject' namespace
-  kn broker create mybroker --namespace myproject
+  # Create a broker 'mybroker' in the 'myproject' namespace and with a broker class of 'Kafka'
+  kn broker create mybroker --namespace myproject --broker Kafka
+
 ```
 
 ### Options
 
 ```
+      --class string       Broker class like 'MTChannelBasedBroker' or 'Kafka' (if available)
   -h, --help               help for create
   -n, --namespace string   Specify the namespace to operate in.
 ```

lib/test/broker.go

@@ -32,6 +32,13 @@ func BrokerCreate(r *KnRunResultCollector, name string) {
 	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Broker", name, "created", "namespace", r.KnTest().Kn().Namespace()))
 }
 
+// BrokerCreateWithClass creates a broker with the given name and class.
+func BrokerCreateWithClass(r *KnRunResultCollector, name, class string) {
+	out := r.KnTest().Kn().Run("broker", "create", name, "--class", class)
+	r.AssertNoError(out)
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, "Broker", name, "created", "namespace", r.KnTest().Kn().Namespace()))
+}
+
 // BrokerDelete deletes a broker with the given name.
 func BrokerDelete(r *KnRunResultCollector, name string, wait bool) {
 	args := []string{"broker", "delete", name}

pkg/eventing/v1/client.go

@@ -325,6 +325,18 @@ func (b *BrokerBuilder) Namespace(ns string) *BrokerBuilder {
 	return b
 }
 
+// Class for broker builder
+func (b *BrokerBuilder) Class(class string) *BrokerBuilder {
+	if class == "" {
+		return b
+	}
+	if len(b.broker.Annotations) == 0 {
+		b.broker.Annotations = make(map[string]string)
+	}
+	b.broker.Annotations[eventingv1.BrokerClassAnnotationKey] = class
+	return b
+}
+
 // Build to return an instance of broker object
 func (b *BrokerBuilder) Build() *eventingv1.Broker {
 	return b.broker

pkg/eventing/v1/client_test.go

@@ -35,7 +35,10 @@ import (
 	duckv1 "knative.dev/pkg/apis/duck/v1"
 )
 
-var testNamespace = "test-ns"
+var (
+	testNamespace = "test-ns"
+	testClass     = "test-class"
+)
 
 func setup() (fakeSvr fake.FakeEventingV1, client KnEventingClient) {
 	fakeE := fake.FakeEventingV1{Fake: &client_testing.Fake{}}
@@ -202,6 +205,7 @@ func TestBrokerCreate(t *testing.T) {
 	server, client := setup()
 
 	objNew := newBroker(name)
+	brokerObjWithClass := newBrokerWithClass(name)
 
 	server.AddReactor("create", "brokers",
 		func(a client_testing.Action) (bool, runtime.Object, error) {
@@ -219,6 +223,11 @@ func TestBrokerCreate(t *testing.T) {
 		assert.NilError(t, err)
 	})
 
+	t.Run("create broker with class without error", func(t *testing.T) {
+		err := client.CreateBroker(context.Background(), brokerObjWithClass)
+		assert.NilError(t, err)
+	})
+
 	t.Run("create broker with an error returns an error object", func(t *testing.T) {
 		err := client.CreateBroker(context.Background(), newBroker("unknown"))
 		assert.ErrorContains(t, err, "unknown")
@@ -361,6 +370,14 @@ func newTrigger(name string) *eventingv1.Trigger {
 func newBroker(name string) *eventingv1.Broker {
 	return NewBrokerBuilder(name).
 		Namespace(testNamespace).
+		Class("").
+		Build()
+}
+
+func newBrokerWithClass(name string) *eventingv1.Broker {
+	return NewBrokerBuilder(name).
+		Namespace(testNamespace).
+		Class(testClass).
 		Build()
 }
 

pkg/kn/commands/broker/broker_test.go

@@ -77,3 +77,7 @@ func createBroker(brokerName string) *v1beta1.Broker {
 func createBrokerWithNamespace(brokerName, namespace string) *v1beta1.Broker {
 	return clientv1beta1.NewBrokerBuilder(brokerName).Namespace(namespace).Build()
 }
+
+func createBrokerWithClass(brokerName, class string) *v1beta1.Broker {
+	return clientv1beta1.NewBrokerBuilder(brokerName).Namespace("default").Class(class).Build()
+}

pkg/kn/commands/broker/create.go

@@ -30,12 +30,15 @@ var createExample = `
   # Create a broker 'mybroker' in the current namespace
   kn broker create mybroker
 
-  # Create a broker 'mybroker' in the 'myproject' namespace
-  kn broker create mybroker --namespace myproject`
+  # Create a broker 'mybroker' in the 'myproject' namespace and with a broker class of 'Kafka'
+  kn broker create mybroker --namespace myproject --broker Kafka
+`
 
 // NewBrokerCreateCommand represents command to create new broker instance
 func NewBrokerCreateCommand(p *commands.KnParams) *cobra.Command {
 
+	var className string
+
 	cmd := &cobra.Command{
 		Use:     "create NAME",
 		Short:   "Create a broker",
@@ -58,7 +61,8 @@ func NewBrokerCreateCommand(p *commands.KnParams) *cobra.Command {
 
 			brokerBuilder := clientv1beta1.
 				NewBrokerBuilder(name).
-				Namespace(namespace)
+				Namespace(namespace).
+				Class(className)
 
 			err = eventingClient.CreateBroker(cmd.Context(), brokerBuilder.Build())
 			if err != nil {
@@ -71,5 +75,6 @@ func NewBrokerCreateCommand(p *commands.KnParams) *cobra.Command {
 		},
 	}
 	commands.AddNamespaceFlags(cmd.Flags(), false)
+	cmd.Flags().StringVar(&className, "class", "", "Broker class like 'MTChannelBasedBroker' or 'Kafka' (if available)")
 	return cmd
 }

pkg/kn/commands/broker/create_test.go

@@ -27,6 +27,7 @@ import (
 
 var (
 	brokerName = "foo"
+	className  = "foo-class"
 )
 
 func TestBrokerCreate(t *testing.T) {
@@ -42,6 +43,24 @@ func TestBrokerCreate(t *testing.T) {
 	eventingRecorder.Validate()
 }
 
+func TestBrokerCreateWithClass(t *testing.T) {
+	eventingClient := clienteventingv1.NewMockKnEventingClient(t)
+
+	eventingRecorder := eventingClient.Recorder()
+	eventingRecorder.CreateBroker(createBrokerWithClass(brokerName, className), nil)
+
+	out, err := executeBrokerCommand(eventingClient, "create", brokerName, "--class", className)
+	assert.NilError(t, err, "Broker should be created")
+	assert.Assert(t, util.ContainsAll(out, "Broker", brokerName, "created", "namespace", "default"))
+
+	eventingRecorder.CreateBroker(createBrokerWithClass(brokerName, ""), nil)
+	out, err = executeBrokerCommand(eventingClient, "create", brokerName, "--class", "")
+	assert.NilError(t, err, "Broker should be created")
+	assert.Assert(t, util.ContainsAll(out, "Broker", brokerName, "created", "namespace", "default"))
+
+	eventingRecorder.Validate()
+}
+
 func TestBrokerCreateWithError(t *testing.T) {
 	eventingClient := clienteventingv1.NewMockKnEventingClient(t)
 

test/e2e/broker_test.go

@@ -59,6 +59,12 @@ func TestBroker(t *testing.T) {
 	test.BrokerDelete(r, "foo4", true)
 	verifyBrokerNotfound(r, "foo3")
 	verifyBrokerNotfound(r, "foo4")
+
+	t.Log("create broker with class")
+	test.BrokerCreateWithClass(r, "foo5", "foo-class")
+	verifyBrokerList(r, "foo5")
+	verifyBrokerListOutputName(r, "foo5")
+	verifyBrokerDescribeContains(r, "foo5", "foo-class")
 }
 
 // Private functions
@@ -86,3 +92,9 @@ func verifyBrokerNotfound(r *test.KnRunResultCollector, name string) {
 	r.AssertError(out)
 	assert.Check(r.T(), util.ContainsAll(out.Stderr, name, "not found"))
 }
+
+func verifyBrokerDescribeContains(r *test.KnRunResultCollector, name, str string) {
+	out := r.KnTest().Kn().Run("broker", "describe", name)
+	r.AssertNoError(out)
+	assert.Check(r.T(), util.ContainsAllIgnoreCase(out.Stdout, name, str))
+}