small additions, improved naming, fixed typos

Author: metlos

testsupport/assertions/assertions.go

@@ -27,9 +27,9 @@ func AppendGeneric[SuperType any, Type any](assertionList Assertions[Type], asse
 	return assertionList
 }
 
-// AppendLifted is a convenience function to first lift all the assertions to the "To" type and then append them to the provided list.
-func AppendLifted[From any, To any](conversion func(To) (From, bool), assertionList Assertions[To], assertions ...Assertion[From]) Assertions[To] {
-	return Append(assertionList, LiftAll(conversion, assertions...)...)
+// AppendConverted is a convenience function to first lift all the assertions to the "To" type and then append them to the provided list.
+func AppendConverted[From any, To any](conversion func(To) (From, bool), assertionList Assertions[To], assertions ...Assertion[From]) Assertions[To] {
+	return Append(assertionList, ConvertAll(conversion, assertions...)...)
 }
 
 // AppendFunc is a convenience function that is able to take in the assertions as simple functions.

testsupport/assertions/conditions/conditions.go

@@ -5,6 +5,7 @@ import (
 	"github.com/codeready-toolchain/toolchain-common/pkg/condition"
 	"github.com/codeready-toolchain/toolchain-e2e/testsupport/assertions"
 	"github.com/stretchr/testify/assert"
+	corev1 "k8s.io/api/core/v1"
 )
 
 type ConditionAssertions struct {
@@ -23,3 +24,24 @@ func (cas *ConditionAssertions) Type(typ toolchainv1alpha1.ConditionType) *Condi
 	})
 	return cas
 }
+
+func (cas *ConditionAssertions) Status(typ toolchainv1alpha1.ConditionType, status corev1.ConditionStatus) *ConditionAssertions {
+	cas.Assertions = assertions.AppendFunc(cas.Assertions, func(t assertions.AssertT, conds []toolchainv1alpha1.Condition) {
+		t.Helper()
+		cond, found := condition.FindConditionByType(conds, typ)
+		assert.True(t, found, "didn't find a condition with the type '%v'", typ)
+		assert.Equal(t, status, cond.Status, "condition of type '%v' doesn't have the expected status", typ)
+	})
+	return cas
+}
+
+func (cas *ConditionAssertions) StatusAndReason(typ toolchainv1alpha1.ConditionType, status corev1.ConditionStatus, reason string) *ConditionAssertions {
+	cas.Assertions = assertions.AppendFunc(cas.Assertions, func(t assertions.AssertT, conds []toolchainv1alpha1.Condition) {
+		t.Helper()
+		cond, found := condition.FindConditionByType(conds, typ)
+		assert.True(t, found, "didn't find a condition with the type '%v'", typ)
+		assert.Equal(t, status, cond.Status, "condition of type '%v' doesn't have the expected status", typ)
+		assert.Equal(t, reason, cond.Reason, "condition of type '%v' doesn't have the expected reason", typ)
+	})
+	return cas
+}

testsupport/assertions/lift.go testsupport/assertions/convert.gotestsupport/assertions/lift.go renamed to testsupport/assertions/convert.go

@@ -9,28 +9,28 @@ func CastAssertion[SuperType any, Type any](a Assertion[SuperType]) Assertion[Ty
 		return cast[SuperType](o)
 	}
 
-	return Lift(conversion, a)
+	return Convert(conversion, a)
 }
 
-// Lift converts from one assertion type to another by converting the tested value.
+// Convert converts from one assertion type to another by converting the tested value.
 // It respectes the ObjectNameAssertion and ObjectNamespaceAssertion so that assertions
 // can still be used to identify the object after lifting.
 // The provided accessor can be fallible, returning false on the failure to convert the object.
-func Lift[From any, To any](accessor func(To) (From, bool), assertion Assertion[From]) Assertion[To] {
+func Convert[From any, To any](accessor func(To) (From, bool), assertion Assertion[From]) Assertion[To] {
 	if _, ok := assertion.(ObjectNameAssertion); ok {
-		return &liftedObjectName[From, To]{liftedAssertion: liftedAssertion[From, To]{accessor: accessor, assertion: assertion}}
+		return &convertedObjectName[From, To]{convertedAssertion: convertedAssertion[From, To]{accessor: accessor, assertion: assertion}}
 	} else if _, ok := assertion.(ObjectNamespaceAssertion); ok {
-		return &liftedObjectNamespace[From, To]{liftedAssertion: liftedAssertion[From, To]{accessor: accessor, assertion: assertion}}
+		return &convertedObjectNamespace[From, To]{convertedAssertion: convertedAssertion[From, To]{accessor: accessor, assertion: assertion}}
 	} else {
-		return &liftedAssertion[From, To]{accessor: accessor, assertion: assertion}
+		return &convertedAssertion[From, To]{accessor: accessor, assertion: assertion}
 	}
 }
 
-// LiftAll performs Lift on all the provided assertions.
-func LiftAll[From any, To any](accessor func(To) (From, bool), assertions ...Assertion[From]) Assertions[To] {
+// ConvertAll performs Lift on all the provided assertions.
+func ConvertAll[From any, To any](accessor func(To) (From, bool), assertions ...Assertion[From]) Assertions[To] {
 	tos := make(Assertions[To], len(assertions))
 	for i, a := range assertions {
-		tos[i] = Lift(accessor, a)
+		tos[i] = Convert(accessor, a)
 	}
 	return tos
 }
@@ -44,12 +44,12 @@ func cast[T any](obj any) (T, bool) {
 	return ret, ok
 }
 
-type liftedAssertion[From any, To any] struct {
+type convertedAssertion[From any, To any] struct {
 	assertion Assertion[From]
 	accessor  func(To) (From, bool)
 }
 
-func (lon *liftedAssertion[From, To]) Test(t AssertT, obj To) {
+func (lon *convertedAssertion[From, To]) Test(t AssertT, obj To) {
 	t.Helper()
 	o, ok := lon.accessor(obj)
 	if !ok {
@@ -59,18 +59,18 @@ func (lon *liftedAssertion[From, To]) Test(t AssertT, obj To) {
 	lon.assertion.Test(t, o)
 }
 
-type liftedObjectName[From any, To any] struct {
-	liftedAssertion[From, To]
+type convertedObjectName[From any, To any] struct {
+	convertedAssertion[From, To]
 }
 
-func (lon *liftedObjectName[From, To]) Name() string {
+func (lon *convertedObjectName[From, To]) Name() string {
 	return lon.assertion.(ObjectNameAssertion).Name()
 }
 
-type liftedObjectNamespace[From any, To any] struct {
-	liftedAssertion[From, To]
+type convertedObjectNamespace[From any, To any] struct {
+	convertedAssertion[From, To]
 }
 
-func (lon *liftedObjectNamespace[From, To]) Namespace() string {
+func (lon *convertedObjectNamespace[From, To]) Namespace() string {
 	return lon.assertion.(ObjectNamespaceAssertion).Namespace()
 }

testsupport/assertions/metadata/metadata.go

@@ -57,6 +57,14 @@ func (ma *MetadataAssertions) Label(name string) *MetadataAssertions {
 	return ma
 }
 
+func (ma *MetadataAssertions) NoLabel(name string) *MetadataAssertions {
+	ma.Assertions = assertions.AppendFunc(ma.Assertions, func(t assertions.AssertT, obj client.Object) {
+		t.Helper()
+		assert.NotContains(t, obj.GetLabels(), name, "a label called '%s' found on the object but none expected", name)
+	})
+	return ma
+}
+
 func (a *objectName) Test(t assertions.AssertT, obj client.Object) {
 	t.Helper()
 	assert.Equal(t, a.name, obj.GetName(), "object name doesn't match")

testsupport/assertions/object.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/codeready-toolchain/toolchain-e2e/testsupport/wait"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
@@ -18,6 +17,11 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
+const (
+	DefaultRetryInterval = time.Millisecond * 100 // make it short because a "retry interval" is waited before the first test
+	DefaultTimeout       = time.Second * 120
+)
+
 type AddressableObjectAssertions[T client.Object] struct {
 	Assertions[T]
 }
@@ -50,8 +54,8 @@ type errorCollectingT struct {
 func (oa *AddressableObjectAssertions[T]) Await(cl client.Client) *Await[T] {
 	return &Await[T]{
 		cl:         cl,
-		timeout:    wait.DefaultTimeout,
-		tick:       wait.DefaultRetryInterval,
+		timeout:    DefaultTimeout,
+		tick:       DefaultRetryInterval,
 		assertions: oa.Assertions,
 	}
 }

testsupport/assertions/object/object.go

@@ -6,8 +6,14 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
-// ObjectAssertions is a common base for assertions on client.Object subtypes.
+// ObjectAssertions is a common base for assertions on client.Object subtypes
+// and is meant to be embedded in other structs.
+//
 // It provides assertions on the object metadata.
+//
+// It is necessary to initialize this using the SetFluentSelf method so that
+// the methods defined on this struct can participate in the fluent call-chains
+// defined on the struct that embeds it.
 type ObjectAssertions[Self any, T client.Object] struct {
 	assertions.AddressableObjectAssertions[T]
 	self *Self

testsupport/assertions/spaceprovisionerconfig/spc.go

@@ -1,15 +1,15 @@
 package spaceprovisionerconfig
 
 import (
-	toolchainv1aplha1 "github.com/codeready-toolchain/api/api/v1alpha1"
+	toolchainv1alpha1 "github.com/codeready-toolchain/api/api/v1alpha1"
 	"github.com/codeready-toolchain/toolchain-e2e/testsupport/assertions"
 	"github.com/codeready-toolchain/toolchain-e2e/testsupport/assertions/conditions"
 	"github.com/codeready-toolchain/toolchain-e2e/testsupport/assertions/object"
 	"github.com/stretchr/testify/assert"
 )
 
 type SpaceProvisionerConfigAssertions struct {
-	object.ObjectAssertions[SpaceProvisionerConfigAssertions, *toolchainv1aplha1.SpaceProvisionerConfig]
+	object.ObjectAssertions[SpaceProvisionerConfigAssertions, *toolchainv1alpha1.SpaceProvisionerConfig]
 }
 
 func Asserting() *SpaceProvisionerConfigAssertions {
@@ -19,18 +19,18 @@ func Asserting() *SpaceProvisionerConfigAssertions {
 }
 
 func (spc *SpaceProvisionerConfigAssertions) Conditions(cas *conditions.ConditionAssertions) *SpaceProvisionerConfigAssertions {
-	spc.Assertions = assertions.AppendLifted(getConditions, spc.Assertions, cas.Assertions...)
+	spc.Assertions = assertions.AppendConverted(getConditions, spc.Assertions, cas.Assertions...)
 	return spc
 }
 
 func (spc *SpaceProvisionerConfigAssertions) ToolchainClusterName(name string) *SpaceProvisionerConfigAssertions {
-	spc.Assertions = assertions.AppendFunc(spc.Assertions, func(t assertions.AssertT, obj *toolchainv1aplha1.SpaceProvisionerConfig) {
+	spc.Assertions = assertions.AppendFunc(spc.Assertions, func(t assertions.AssertT, obj *toolchainv1alpha1.SpaceProvisionerConfig) {
 		t.Helper()
 		assert.Equal(t, name, obj.Spec.ToolchainCluster, "unexpected toolchainCluster")
 	})
 	return spc
 }
 
-func getConditions(spc *toolchainv1aplha1.SpaceProvisionerConfig) ([]toolchainv1aplha1.Condition, bool) {
+func getConditions(spc *toolchainv1alpha1.SpaceProvisionerConfig) ([]toolchainv1alpha1.Condition, bool) {
 	return spc.Status.Conditions, true
 }

testsupport/assertions_use/assertions_test.go

@@ -3,6 +3,7 @@ package assertions_use
 import (
 	"context"
 	"testing"
+	"time"
 
 	toolchainv1aplha1 "github.com/codeready-toolchain/api/api/v1alpha1"
 	"github.com/codeready-toolchain/toolchain-e2e/testsupport/assertions/conditions"
@@ -17,7 +18,7 @@ import (
 func Test(t *testing.T) {
 	spcUnderTest := &toolchainv1aplha1.SpaceProvisionerConfig{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:      "kachny",
+			Name:      "myobj",
 			Namespace: "default",
 		},
 	}
@@ -26,17 +27,18 @@ func Test(t *testing.T) {
 	require.NoError(t, toolchainv1aplha1.AddToScheme(scheme))
 
 	// use the assertions in a simple immediate call
-	spaceprovisionerconfig.Asserting().
-		ObjectMeta(metadata.With().Name("asdf").Label("kachny")).
-		Conditions(conditions.With().Type(toolchainv1aplha1.ConditionReady)).
-		Test(t, spcUnderTest)
+	// spaceprovisionerconfig.Asserting().
+	// 	ObjectMeta(metadata.With().Name("asdf").Label("kachny")).
+	// 	Conditions(conditions.With().Type(toolchainv1aplha1.ConditionReady)).
+	// 	Test(t, spcUnderTest)
 
 	cl := fake.NewClientBuilder().WithScheme(scheme).WithRuntimeObjects(spcUnderTest).Build()
 
 	// this is the new WaitFor
 	spaceprovisionerconfig.Asserting().
-		ObjectMeta(metadata.With().Name("asdf").Namespace("default").Label("kachny")).
+		ObjectMeta(metadata.With().Name("myobj").Namespace("default").Label("requiredLabel")).
 		Conditions(conditions.With().Type(toolchainv1aplha1.ConditionReady)).
 		Await(cl).
+		WithTimeout(1*time.Second).
 		Matching(context.TODO(), t)
 }