mirror of https://github.com/knative/client.git
770 lines
27 KiB
Go
770 lines
27 KiB
Go
// Copyright © 2019 The Knative Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package v1
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"gotest.tools/v3/assert"
|
|
"k8s.io/apimachinery/pkg/api/errors"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/watch"
|
|
v1 "knative.dev/eventing/pkg/apis/duck/v1"
|
|
|
|
corev1 "k8s.io/api/core/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
client_testing "k8s.io/client-go/testing"
|
|
"knative.dev/client/pkg/wait"
|
|
eventingv1 "knative.dev/eventing/pkg/apis/eventing/v1"
|
|
"knative.dev/eventing/pkg/client/clientset/versioned/typed/eventing/v1/fake"
|
|
"knative.dev/pkg/apis"
|
|
duckv1 "knative.dev/pkg/apis/duck/v1"
|
|
)
|
|
|
|
var (
|
|
testNamespace = "test-ns"
|
|
testClass = "test-class"
|
|
testConfig = &duckv1.KReference{
|
|
Kind: "ConfigMap",
|
|
Namespace: "test-ns",
|
|
Name: "test-cm",
|
|
APIVersion: "v1",
|
|
}
|
|
)
|
|
|
|
func setup() (fakeSvr fake.FakeEventingV1, client KnEventingClient) {
|
|
fakeE := fake.FakeEventingV1{Fake: &client_testing.Fake{}}
|
|
cli := NewKnEventingClient(&fakeE, testNamespace)
|
|
return fakeE, cli
|
|
}
|
|
|
|
func TestNamespace(t *testing.T) {
|
|
_, client := setup()
|
|
assert.Equal(t, testNamespace, client.Namespace())
|
|
}
|
|
|
|
func TestDeleteTrigger(t *testing.T) {
|
|
var name = "new-trigger"
|
|
server, client := setup()
|
|
|
|
server.AddReactor("delete", "triggers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.DeleteAction).GetName()
|
|
if name == "errorTrigger" {
|
|
return true, nil, fmt.Errorf("error while deleting trigger %s", name)
|
|
}
|
|
return true, nil, nil
|
|
})
|
|
|
|
err := client.DeleteTrigger(context.Background(), name)
|
|
assert.NilError(t, err)
|
|
|
|
err = client.DeleteTrigger(context.Background(), "errorTrigger")
|
|
assert.ErrorContains(t, err, "errorTrigger")
|
|
}
|
|
|
|
func TestCreateTrigger(t *testing.T) {
|
|
var name = "new-trigger"
|
|
server, client := setup()
|
|
|
|
objNew := newTrigger(name)
|
|
|
|
server.AddReactor("create", "triggers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
assert.Equal(t, testNamespace, a.GetNamespace())
|
|
name := a.(client_testing.CreateAction).GetObject().(metav1.Object).GetName()
|
|
if name == objNew.Name {
|
|
objNew.Generation = 2
|
|
return true, objNew, nil
|
|
}
|
|
return true, nil, fmt.Errorf("error while creating trigger %s", name)
|
|
})
|
|
|
|
t.Run("create trigger without error", func(t *testing.T) {
|
|
err := client.CreateTrigger(context.Background(), objNew)
|
|
assert.NilError(t, err)
|
|
})
|
|
|
|
t.Run("create trigger with an error returns an error object", func(t *testing.T) {
|
|
err := client.CreateTrigger(context.Background(), newTrigger("unknown"))
|
|
assert.ErrorContains(t, err, "unknown")
|
|
})
|
|
}
|
|
|
|
func TestGetTrigger(t *testing.T) {
|
|
var name = "mytrigger"
|
|
server, client := setup()
|
|
|
|
server.AddReactor("get", "triggers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.GetAction).GetName()
|
|
if name == "errorTrigger" {
|
|
return true, nil, fmt.Errorf("error while getting trigger %s", name)
|
|
}
|
|
return true, newTrigger(name), nil
|
|
})
|
|
|
|
trigger, err := client.GetTrigger(context.Background(), name)
|
|
assert.NilError(t, err)
|
|
assert.Equal(t, trigger.Name, name)
|
|
assert.Equal(t, trigger.Spec.Broker, "default")
|
|
|
|
_, err = client.GetTrigger(context.Background(), "errorTrigger")
|
|
assert.ErrorContains(t, err, "errorTrigger")
|
|
}
|
|
|
|
func TestListTrigger(t *testing.T) {
|
|
serving, client := setup()
|
|
|
|
t.Run("list trigger returns a list of triggers", func(t *testing.T) {
|
|
trigger1 := newTrigger("trigger-1")
|
|
trigger2 := newTrigger("trigger-2")
|
|
|
|
serving.AddReactor("list", "triggers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
assert.Equal(t, testNamespace, a.GetNamespace())
|
|
return true, &eventingv1.TriggerList{Items: []eventingv1.Trigger{*trigger1, *trigger2}}, nil
|
|
})
|
|
|
|
listTriggers, err := client.ListTriggers(context.Background())
|
|
assert.NilError(t, err)
|
|
assert.Assert(t, len(listTriggers.Items) == 2)
|
|
assert.Equal(t, listTriggers.Items[0].Name, "trigger-1")
|
|
assert.Equal(t, listTriggers.Items[1].Name, "trigger-2")
|
|
})
|
|
}
|
|
|
|
func TestUpdateTrigger(t *testing.T) {
|
|
serving, client := setup()
|
|
t.Run("update trigger will update the trigger",
|
|
func(t *testing.T) {
|
|
trigger := newTrigger("trigger-1")
|
|
errTrigger := newTrigger("errorTrigger")
|
|
serving.AddReactor("update", "triggers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
newTrigger := a.(client_testing.UpdateAction).GetObject()
|
|
name := newTrigger.(metav1.Object).GetName()
|
|
if name == "errorTrigger" {
|
|
return true, nil, errors.NewInternalError(fmt.Errorf("mock internal error"))
|
|
}
|
|
return true, trigger, nil
|
|
})
|
|
err := client.UpdateTrigger(context.Background(), trigger)
|
|
assert.NilError(t, err)
|
|
err = client.UpdateTrigger(context.Background(), errTrigger)
|
|
assert.ErrorType(t, err, errors.IsInternalError)
|
|
})
|
|
}
|
|
|
|
func TestUpdateTriggerWithRetry(t *testing.T) {
|
|
serving, client := setup()
|
|
var attemptCount, maxAttempts = 0, 5
|
|
serving.AddReactor("get", "triggers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.GetAction).GetName()
|
|
if name == "deletedTrigger" {
|
|
trigger := newTrigger(name)
|
|
now := metav1.Now()
|
|
trigger.DeletionTimestamp = &now
|
|
return true, trigger, nil
|
|
}
|
|
if name == "getErrorTrigger" {
|
|
return true, nil, errors.NewInternalError(fmt.Errorf("mock internal error"))
|
|
}
|
|
return true, newTrigger(name), nil
|
|
})
|
|
|
|
serving.AddReactor("update", "triggers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
newTrigger := a.(client_testing.UpdateAction).GetObject()
|
|
name := newTrigger.(metav1.Object).GetName()
|
|
|
|
if name == "testTrigger" && attemptCount > 0 {
|
|
attemptCount--
|
|
return true, nil, errors.NewConflict(eventingv1.Resource("trigger"), "errorTrigger", fmt.Errorf("error updating because of conflict"))
|
|
}
|
|
if name == "errorTrigger" {
|
|
return true, nil, errors.NewInternalError(fmt.Errorf("mock internal error"))
|
|
}
|
|
return true, NewTriggerBuilderFromExisting(newTrigger.(*eventingv1.Trigger)).Build(), nil
|
|
})
|
|
|
|
t.Run("Update trigger successfully without any retries", func(t *testing.T) {
|
|
err := client.UpdateTriggerWithRetry(context.Background(), "testTrigger", func(trigger *eventingv1.Trigger) (*eventingv1.Trigger, error) {
|
|
return trigger, nil
|
|
}, maxAttempts)
|
|
assert.NilError(t, err, "No retries required as no conflict error occurred")
|
|
})
|
|
|
|
t.Run("Update trigger with retry after max retries", func(t *testing.T) {
|
|
attemptCount = maxAttempts - 1
|
|
err := client.UpdateTriggerWithRetry(context.Background(), "testTrigger", func(trigger *eventingv1.Trigger) (*eventingv1.Trigger, error) {
|
|
return trigger, nil
|
|
}, maxAttempts)
|
|
assert.NilError(t, err, "Update retried %d times and succeeded", maxAttempts)
|
|
assert.Equal(t, attemptCount, 0)
|
|
})
|
|
|
|
t.Run("Update trigger with retry and fail with conflict after exhausting max retries", func(t *testing.T) {
|
|
attemptCount = maxAttempts
|
|
err := client.UpdateTriggerWithRetry(context.Background(), "testTrigger", func(trigger *eventingv1.Trigger) (*eventingv1.Trigger, error) {
|
|
return trigger, nil
|
|
}, maxAttempts)
|
|
assert.ErrorType(t, err, errors.IsConflict, "Update retried %d times and failed", maxAttempts)
|
|
assert.Equal(t, attemptCount, 0)
|
|
})
|
|
|
|
t.Run("Update trigger with retry and fail with conflict after exhausting max retries", func(t *testing.T) {
|
|
attemptCount = maxAttempts
|
|
err := client.UpdateTriggerWithRetry(context.Background(), "testTrigger", func(trigger *eventingv1.Trigger) (*eventingv1.Trigger, error) {
|
|
return trigger, nil
|
|
}, maxAttempts)
|
|
assert.ErrorType(t, err, errors.IsConflict, "Update retried %d times and failed", maxAttempts)
|
|
assert.Equal(t, attemptCount, 0)
|
|
})
|
|
|
|
t.Run("Update trigger with retry fails with a non conflict error", func(t *testing.T) {
|
|
err := client.UpdateTriggerWithRetry(context.Background(), "errorTrigger", func(trigger *eventingv1.Trigger) (*eventingv1.Trigger, error) {
|
|
return trigger, nil
|
|
}, maxAttempts)
|
|
assert.ErrorType(t, err, errors.IsInternalError)
|
|
})
|
|
|
|
t.Run("Update trigger with retry fails with resource already deleted error", func(t *testing.T) {
|
|
err := client.UpdateTriggerWithRetry(context.Background(), "deletedTrigger", func(trigger *eventingv1.Trigger) (*eventingv1.Trigger, error) {
|
|
return trigger, nil
|
|
}, maxAttempts)
|
|
assert.ErrorContains(t, err, "marked for deletion")
|
|
})
|
|
|
|
t.Run("Update trigger with retry fails with error from updateFunc", func(t *testing.T) {
|
|
err := client.UpdateTriggerWithRetry(context.Background(), "testTrigger", func(trigger *eventingv1.Trigger) (*eventingv1.Trigger, error) {
|
|
return trigger, fmt.Errorf("error updating object")
|
|
}, maxAttempts)
|
|
assert.ErrorContains(t, err, "error updating object")
|
|
})
|
|
|
|
t.Run("Update trigger with retry fails with error from GetTrigger", func(t *testing.T) {
|
|
err := client.UpdateTriggerWithRetry(context.Background(), "getErrorTrigger", func(trigger *eventingv1.Trigger) (*eventingv1.Trigger, error) {
|
|
return trigger, nil
|
|
}, maxAttempts)
|
|
assert.ErrorType(t, err, errors.IsInternalError)
|
|
})
|
|
}
|
|
|
|
func TestTriggerBuilder(t *testing.T) {
|
|
a := NewTriggerBuilder("testtrigger")
|
|
a.Filters(map[string]string{"type": "foo"})
|
|
|
|
t.Run("update filters", func(t *testing.T) {
|
|
b := NewTriggerBuilderFromExisting(a.Build())
|
|
assert.DeepEqual(t, b.Build(), a.Build())
|
|
b.Filters(map[string]string{"type": "new"})
|
|
expected := &eventingv1.TriggerFilter{
|
|
Attributes: eventingv1.TriggerFilterAttributes{
|
|
"type": "new",
|
|
},
|
|
}
|
|
assert.DeepEqual(t, expected, b.Build().Spec.Filter)
|
|
})
|
|
|
|
t.Run("update filters with both new entry and updated entry", func(t *testing.T) {
|
|
b := NewTriggerBuilderFromExisting(a.Build())
|
|
assert.DeepEqual(t, b.Build(), a.Build())
|
|
b.Filters(map[string]string{"type": "new", "source": "bar"})
|
|
expected := &eventingv1.TriggerFilter{
|
|
Attributes: eventingv1.TriggerFilterAttributes{
|
|
"type": "new",
|
|
"source": "bar",
|
|
},
|
|
}
|
|
assert.DeepEqual(t, expected, b.Build().Spec.Filter)
|
|
})
|
|
|
|
t.Run("update filters to remove filters", func(t *testing.T) {
|
|
b := NewTriggerBuilderFromExisting(a.Build())
|
|
assert.DeepEqual(t, b.Build(), a.Build())
|
|
b.Filters(nil)
|
|
expected := &eventingv1.TriggerFilter{}
|
|
assert.DeepEqual(t, expected, b.Build().Spec.Filter)
|
|
|
|
b.Filters((make(map[string]string)))
|
|
assert.DeepEqual(t, expected, b.Build().Spec.Filter)
|
|
})
|
|
|
|
t.Run("add and remove inject annotation", func(t *testing.T) {
|
|
b := NewTriggerBuilder("broker-trigger")
|
|
b.InjectBroker(true)
|
|
expected := &metav1.ObjectMeta{
|
|
Annotations: map[string]string{
|
|
eventingv1.InjectionAnnotation: "enabled",
|
|
},
|
|
}
|
|
assert.DeepEqual(t, expected.Annotations, b.Build().ObjectMeta.Annotations)
|
|
|
|
b = NewTriggerBuilderFromExisting(b.Build())
|
|
b.InjectBroker(false)
|
|
assert.DeepEqual(t, make(map[string]string), b.Build().ObjectMeta.Annotations)
|
|
|
|
})
|
|
}
|
|
|
|
func TestWithGvk(t *testing.T) {
|
|
t.Run("Broker withGvk", func(t *testing.T) {
|
|
b := NewBrokerBuilder("test").WithGvk().Build()
|
|
assert.Assert(t, !b.GroupVersionKind().Empty())
|
|
})
|
|
t.Run("Trigger withGvk", func(t *testing.T) {
|
|
trigger := NewTriggerBuilder("test").WithGvk().Build()
|
|
assert.Assert(t, !trigger.GroupVersionKind().Empty())
|
|
})
|
|
}
|
|
|
|
func TestBrokerCreate(t *testing.T) {
|
|
var name = "broker"
|
|
server, client := setup()
|
|
|
|
objNew := newBroker(name)
|
|
brokerObjWithClass := newBrokerWithClass(name)
|
|
brokerObjWithDeliveryOptions := newBrokerWithDeliveryOptions(name)
|
|
brokerObjWithNilDeliveryOptions := newBrokerWithNilDeliveryOptions(name)
|
|
brokerObjWithConfig := newBrokerWithConfig(name)
|
|
|
|
server.AddReactor("create", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
assert.Equal(t, testNamespace, a.GetNamespace())
|
|
name := a.(client_testing.CreateAction).GetObject().(metav1.Object).GetName()
|
|
if name == objNew.Name {
|
|
objNew.Generation = 2
|
|
return true, objNew, nil
|
|
}
|
|
return true, nil, fmt.Errorf("error while creating broker %s", name)
|
|
})
|
|
|
|
t.Run("create broker without error", func(t *testing.T) {
|
|
err := client.CreateBroker(context.Background(), objNew)
|
|
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")
|
|
})
|
|
|
|
t.Run("create broker with delivery options", func(t *testing.T) {
|
|
err := client.CreateBroker(context.Background(), brokerObjWithDeliveryOptions)
|
|
assert.NilError(t, err)
|
|
})
|
|
|
|
t.Run("create broker with nil delivery options", func(t *testing.T) {
|
|
err := client.CreateBroker(context.Background(), brokerObjWithNilDeliveryOptions)
|
|
assert.NilError(t, err)
|
|
})
|
|
|
|
t.Run("create broker with nil delivery spec", func(t *testing.T) {
|
|
builderFuncs := []func(builder *BrokerBuilder) *BrokerBuilder{
|
|
func(builder *BrokerBuilder) *BrokerBuilder {
|
|
var sink = &duckv1.Destination{
|
|
Ref: &duckv1.KReference{Name: "test-svc", Kind: "Service", APIVersion: "serving.knative.dev/v1", Namespace: "default"},
|
|
}
|
|
return builder.DlSink(sink)
|
|
},
|
|
func(builder *BrokerBuilder) *BrokerBuilder {
|
|
var retry int32 = 5
|
|
return builder.Retry(&retry)
|
|
},
|
|
func(builder *BrokerBuilder) *BrokerBuilder {
|
|
var timeout = "PT5S"
|
|
return builder.Timeout(&timeout)
|
|
},
|
|
func(builder *BrokerBuilder) *BrokerBuilder {
|
|
var policy = v1.BackoffPolicyType("linear")
|
|
return builder.BackoffPolicy(&policy)
|
|
},
|
|
func(builder *BrokerBuilder) *BrokerBuilder {
|
|
var delay = "PT5S"
|
|
return builder.BackoffDelay(&delay)
|
|
},
|
|
func(builder *BrokerBuilder) *BrokerBuilder {
|
|
var max = "PT5S"
|
|
return builder.RetryAfterMax(&max)
|
|
},
|
|
}
|
|
for _, bf := range builderFuncs {
|
|
brokerBuilder := NewBrokerBuilder(name)
|
|
brokerBuilder.broker.Spec.Delivery = nil
|
|
updatedBuilder := bf(brokerBuilder)
|
|
|
|
broker := updatedBuilder.Build()
|
|
err := client.CreateBroker(context.Background(), broker)
|
|
assert.NilError(t, err)
|
|
}
|
|
})
|
|
|
|
t.Run("create broker with spec", func(t *testing.T) {
|
|
err := client.CreateBroker(context.Background(), brokerObjWithConfig)
|
|
assert.NilError(t, err)
|
|
})
|
|
}
|
|
|
|
func TestBrokerGet(t *testing.T) {
|
|
var name = "foo"
|
|
server, client := setup()
|
|
|
|
server.AddReactor("get", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.GetAction).GetName()
|
|
if name == "errorBroker" {
|
|
return true, nil, fmt.Errorf("error while getting broker %s", name)
|
|
}
|
|
return true, newBroker(name), nil
|
|
})
|
|
|
|
broker, err := client.GetBroker(context.Background(), name)
|
|
assert.NilError(t, err)
|
|
assert.Equal(t, broker.Name, name)
|
|
|
|
_, err = client.GetBroker(context.Background(), "errorBroker")
|
|
assert.ErrorContains(t, err, "errorBroker")
|
|
}
|
|
|
|
func TestBrokerDelete(t *testing.T) {
|
|
var name = "fooBroker"
|
|
server, client := setup()
|
|
|
|
server.AddReactor("get", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.GetAction).GetName()
|
|
if name == "notFound" {
|
|
return true, nil, errors.NewNotFound(eventingv1.Resource("broker"), "notFound")
|
|
}
|
|
return false, nil, nil
|
|
})
|
|
server.AddReactor("delete", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.DeleteAction).GetName()
|
|
if name == "errorBroker" {
|
|
return true, nil, fmt.Errorf("error while deleting broker %s", name)
|
|
}
|
|
return false, nil, nil
|
|
})
|
|
|
|
err := client.DeleteBroker(context.Background(), name, 0)
|
|
assert.NilError(t, err)
|
|
|
|
err = client.DeleteBroker(context.Background(), "errorBroker", 0)
|
|
assert.ErrorContains(t, err, "errorBroker", 0)
|
|
|
|
err = client.DeleteBroker(context.Background(), "notFound", 0)
|
|
assert.ErrorContains(t, err, "not found", 0)
|
|
assert.ErrorContains(t, err, "notFound", 0)
|
|
}
|
|
|
|
func TestBrokerDeleteWithWait(t *testing.T) {
|
|
var brokerName = "fooBroker"
|
|
var deleted = "deletedBroker"
|
|
server, client := setup()
|
|
|
|
server.AddReactor("get", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.GetAction).GetName()
|
|
if name == deleted {
|
|
deletedBroker := newBroker(deleted)
|
|
deletedBroker.DeletionTimestamp = &metav1.Time{Time: time.Now()}
|
|
return true, deletedBroker, nil
|
|
}
|
|
return false, nil, nil
|
|
})
|
|
server.AddReactor("delete", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.DeleteAction).GetName()
|
|
if name == "errorBroker" {
|
|
return true, nil, fmt.Errorf("error while deleting broker %s", name)
|
|
}
|
|
if name == deleted {
|
|
deletedBroker := newBroker(deleted)
|
|
deletedBroker.DeletionTimestamp = &metav1.Time{Time: time.Now()}
|
|
return true, deletedBroker, nil
|
|
}
|
|
return true, nil, nil
|
|
})
|
|
server.AddWatchReactor("brokers",
|
|
func(a client_testing.Action) (bool, watch.Interface, error) {
|
|
watchAction := a.(client_testing.WatchAction)
|
|
name, found := watchAction.GetWatchRestrictions().Fields.RequiresExactMatch("metadata.name")
|
|
if !found {
|
|
return true, nil, errors.NewNotFound(eventingv1.Resource("broker"), name)
|
|
}
|
|
w := wait.NewFakeWatch(getBrokerDeleteEvents("fooBroker"))
|
|
w.Start()
|
|
return true, w, nil
|
|
})
|
|
|
|
err := client.DeleteBroker(context.Background(), brokerName, time.Duration(10)*time.Second)
|
|
assert.NilError(t, err)
|
|
|
|
err = client.DeleteBroker(context.Background(), "errorBroker", time.Duration(10)*time.Second)
|
|
assert.ErrorContains(t, err, "errorBroker", time.Duration(10)*time.Second)
|
|
|
|
err = client.DeleteBroker(context.Background(), deleted, time.Duration(10)*time.Second)
|
|
assert.ErrorContains(t, err, "marked for deletion")
|
|
assert.ErrorContains(t, err, deleted, time.Duration(10)*time.Second)
|
|
}
|
|
|
|
func TestBrokerList(t *testing.T) {
|
|
serving, client := setup()
|
|
|
|
t.Run("broker list returns a list of brokers", func(t *testing.T) {
|
|
broker1 := newBrokerWithGvk("foo1")
|
|
broker2 := newBrokerWithGvk("foo2")
|
|
|
|
serving.AddReactor("list", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
assert.Equal(t, testNamespace, a.GetNamespace())
|
|
return true, &eventingv1.BrokerList{Items: []eventingv1.Broker{*broker1, *broker2}}, nil
|
|
})
|
|
|
|
brokerList, err := client.ListBrokers(context.Background())
|
|
assert.NilError(t, err)
|
|
assert.Assert(t, len(brokerList.Items) == 2)
|
|
assert.Equal(t, brokerList.Items[0].Name, "foo1")
|
|
assert.Equal(t, brokerList.Items[1].Name, "foo2")
|
|
assert.Assert(t, !brokerList.GroupVersionKind().Empty())
|
|
assert.Assert(t, !brokerList.Items[0].GroupVersionKind().Empty())
|
|
})
|
|
}
|
|
|
|
func TestBrokerUpdate(t *testing.T) {
|
|
var name = "broker"
|
|
server, client := setup()
|
|
|
|
obj := newBroker(name)
|
|
errorObj := newBroker("error-obj")
|
|
updatedObj := newBrokerWithDeliveryOptions(name)
|
|
|
|
server.AddReactor("update", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
assert.Equal(t, testNamespace, a.GetNamespace())
|
|
name := a.(client_testing.UpdateAction).GetObject().(metav1.Object).GetName()
|
|
if name == "error-obj" {
|
|
return true, nil, fmt.Errorf("error while creating broker %s", name)
|
|
}
|
|
return true, updatedObj, nil
|
|
})
|
|
server.AddReactor("get", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
assert.Equal(t, testNamespace, a.GetNamespace())
|
|
return true, obj, nil
|
|
})
|
|
|
|
t.Run("update broker without error", func(t *testing.T) {
|
|
err := client.UpdateBroker(context.Background(), updatedObj)
|
|
assert.NilError(t, err)
|
|
})
|
|
|
|
t.Run("create broker with an error returns an error object", func(t *testing.T) {
|
|
err := client.UpdateBroker(context.Background(), errorObj)
|
|
assert.ErrorContains(t, err, "error while creating broker")
|
|
})
|
|
}
|
|
|
|
func TestUpdateBrokerWithRetry(t *testing.T) {
|
|
serving, client := setup()
|
|
var attemptCount, maxAttempts = 0, 5
|
|
serving.AddReactor("get", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
name := a.(client_testing.GetAction).GetName()
|
|
if name == "deletedBroker" {
|
|
broker := newBroker(name)
|
|
now := metav1.Now()
|
|
broker.DeletionTimestamp = &now
|
|
return true, broker, nil
|
|
}
|
|
if name == "getErrorBroker" {
|
|
return true, nil, errors.NewInternalError(fmt.Errorf("mock internal error"))
|
|
}
|
|
return true, newBroker(name), nil
|
|
})
|
|
|
|
serving.AddReactor("update", "brokers",
|
|
func(a client_testing.Action) (bool, runtime.Object, error) {
|
|
newBroker := a.(client_testing.UpdateAction).GetObject()
|
|
name := newBroker.(metav1.Object).GetName()
|
|
|
|
if name == "testBroker" && attemptCount > 0 {
|
|
attemptCount--
|
|
return true, nil, errors.NewConflict(eventingv1.Resource("broker"), "errorBroker", fmt.Errorf("error updating because of conflict"))
|
|
}
|
|
if name == "errorBroker" {
|
|
return true, nil, errors.NewInternalError(fmt.Errorf("mock internal error"))
|
|
}
|
|
return true, NewBrokerBuilderFromExisting(newBroker.(*eventingv1.Broker)).Build(), nil
|
|
})
|
|
|
|
t.Run("Update broker successfully without any retries", func(t *testing.T) {
|
|
err := client.UpdateBrokerWithRetry(context.Background(), "testBroker", func(broker *eventingv1.Broker) (*eventingv1.Broker, error) {
|
|
return broker, nil
|
|
}, maxAttempts)
|
|
assert.NilError(t, err, "No retries required as no conflict error occurred")
|
|
})
|
|
|
|
t.Run("Update broker with retry after max retries", func(t *testing.T) {
|
|
attemptCount = maxAttempts - 1
|
|
err := client.UpdateBrokerWithRetry(context.Background(), "testBroker", func(broker *eventingv1.Broker) (*eventingv1.Broker, error) {
|
|
return broker, nil
|
|
}, maxAttempts)
|
|
assert.NilError(t, err, "Update retried %d times and succeeded", maxAttempts)
|
|
assert.Equal(t, attemptCount, 0)
|
|
})
|
|
|
|
t.Run("Update broker with retry and fail with conflict after exhausting max retries", func(t *testing.T) {
|
|
attemptCount = maxAttempts
|
|
err := client.UpdateBrokerWithRetry(context.Background(), "testBroker", func(broker *eventingv1.Broker) (*eventingv1.Broker, error) {
|
|
return broker, nil
|
|
}, maxAttempts)
|
|
assert.ErrorType(t, err, errors.IsConflict, "Update retried %d times and failed", maxAttempts)
|
|
assert.Equal(t, attemptCount, 0)
|
|
})
|
|
|
|
t.Run("Update broker with retry and fail with conflict after exhausting max retries", func(t *testing.T) {
|
|
attemptCount = maxAttempts
|
|
err := client.UpdateBrokerWithRetry(context.Background(), "testBroker", func(broker *eventingv1.Broker) (*eventingv1.Broker, error) {
|
|
return broker, nil
|
|
}, maxAttempts)
|
|
assert.ErrorType(t, err, errors.IsConflict, "Update retried %d times and failed", maxAttempts)
|
|
assert.Equal(t, attemptCount, 0)
|
|
})
|
|
|
|
t.Run("Update broker with retry fails with a non conflict error", func(t *testing.T) {
|
|
err := client.UpdateBrokerWithRetry(context.Background(), "errorBroker", func(broker *eventingv1.Broker) (*eventingv1.Broker, error) {
|
|
return broker, nil
|
|
}, maxAttempts)
|
|
assert.ErrorType(t, err, errors.IsInternalError)
|
|
})
|
|
|
|
t.Run("Update broker with retry fails with resource already deleted error", func(t *testing.T) {
|
|
err := client.UpdateBrokerWithRetry(context.Background(), "deletedBroker", func(broker *eventingv1.Broker) (*eventingv1.Broker, error) {
|
|
return broker, nil
|
|
}, maxAttempts)
|
|
assert.ErrorContains(t, err, "marked for deletion")
|
|
})
|
|
|
|
t.Run("Update broker with retry fails with error from updateFunc", func(t *testing.T) {
|
|
err := client.UpdateBrokerWithRetry(context.Background(), "testBroker", func(broker *eventingv1.Broker) (*eventingv1.Broker, error) {
|
|
return broker, fmt.Errorf("error updating object")
|
|
}, maxAttempts)
|
|
assert.ErrorContains(t, err, "error updating object")
|
|
})
|
|
|
|
t.Run("Update broker with retry fails with error from GetBroker", func(t *testing.T) {
|
|
err := client.UpdateBrokerWithRetry(context.Background(), "getErrorBroker", func(broker *eventingv1.Broker) (*eventingv1.Broker, error) {
|
|
return broker, nil
|
|
}, maxAttempts)
|
|
assert.ErrorType(t, err, errors.IsInternalError)
|
|
})
|
|
}
|
|
|
|
func newTrigger(name string) *eventingv1.Trigger {
|
|
return NewTriggerBuilder(name).
|
|
Namespace(testNamespace).
|
|
Broker("default").
|
|
Filters(map[string]string{"type": "foo"}).
|
|
Build()
|
|
}
|
|
|
|
func newBroker(name string) *eventingv1.Broker {
|
|
return NewBrokerBuilder(name).
|
|
Namespace(testNamespace).
|
|
Class("").
|
|
Build()
|
|
}
|
|
|
|
func newBrokerWithGvk(name string) *eventingv1.Broker {
|
|
return NewBrokerBuilder(name).
|
|
Namespace(testNamespace).
|
|
WithGvk().
|
|
Build()
|
|
}
|
|
|
|
func newBrokerWithClass(name string) *eventingv1.Broker {
|
|
return NewBrokerBuilder(name).
|
|
Namespace(testNamespace).
|
|
Class(testClass).
|
|
Build()
|
|
}
|
|
func newBrokerWithConfig(name string) *eventingv1.Broker {
|
|
return NewBrokerBuilder(name).
|
|
Namespace(testNamespace).
|
|
Class(testClass).
|
|
Config(testConfig).
|
|
Build()
|
|
}
|
|
|
|
func newBrokerWithDeliveryOptions(name string) *eventingv1.Broker {
|
|
sink := &duckv1.Destination{
|
|
Ref: &duckv1.KReference{Name: "test-svc", Kind: "Service", APIVersion: "serving.knative.dev/v1", Namespace: "default"},
|
|
}
|
|
testTimeout := "PT10S"
|
|
retry := int32(2)
|
|
policy := v1.BackoffPolicyType("linear")
|
|
return NewBrokerBuilder(name).
|
|
Namespace(testNamespace).
|
|
DlSink(sink).
|
|
Timeout(&testTimeout).
|
|
Retry(&retry).
|
|
BackoffDelay(&testTimeout).
|
|
BackoffPolicy(&policy).
|
|
RetryAfterMax(&testTimeout).
|
|
Build()
|
|
}
|
|
|
|
func newBrokerWithNilDeliveryOptions(name string) *eventingv1.Broker {
|
|
return NewBrokerBuilder(name).
|
|
Namespace(testNamespace).
|
|
DlSink(nil).
|
|
Timeout(nil).
|
|
Retry(nil).
|
|
BackoffDelay(nil).
|
|
BackoffPolicy(nil).
|
|
RetryAfterMax(nil).
|
|
Build()
|
|
}
|
|
|
|
func getBrokerDeleteEvents(name string) []watch.Event {
|
|
return []watch.Event{
|
|
{Type: watch.Added, Object: createBrokerWithConditions(name, corev1.ConditionUnknown, corev1.ConditionUnknown, "", "msg1")},
|
|
{Type: watch.Modified, Object: createBrokerWithConditions(name, corev1.ConditionUnknown, corev1.ConditionTrue, "", "msg2")},
|
|
{Type: watch.Deleted, Object: createBrokerWithConditions(name, corev1.ConditionTrue, corev1.ConditionTrue, "", "")},
|
|
}
|
|
}
|
|
|
|
func createBrokerWithConditions(name string, readyStatus corev1.ConditionStatus, otherReadyStatus corev1.ConditionStatus, reason string, message string) runtime.Object {
|
|
broker := newBroker(name)
|
|
broker.Status.Conditions = duckv1.Conditions([]apis.Condition{
|
|
{Type: "ChannelServiceReady", Status: otherReadyStatus},
|
|
{Type: apis.ConditionReady, Status: readyStatus, Reason: reason, Message: message},
|
|
{Type: "Addressable", Status: otherReadyStatus},
|
|
})
|
|
return broker
|
|
}
|