test for deleting resource

Author: Tomek

controllers/kafkaschema_controller_test.go

@@ -4,91 +4,46 @@ import (
 	"context"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
+	"github.com/onsi/gomega/types"
 	"kafka-schema-operator/api/v2beta1"
 	schemareg_mock "kafka-schema-operator/schemareg-mock"
 	"strconv"
 	"time"
 )
 
-const ResourceNs = "default"
-
 var _ = Describe("KafkaschemaController", func() {
 
 	BeforeEach(func() {
 		srMock.Clear()
 	})
+	ctx := context.Background()
+
 	Context("When creating resource", func() {
 
 		It("Should register subject+schema and manage resource status", func() {
 			topicName := "testenv.testservice.testevent." + strconv.FormatInt(time.Now().UnixMilli(), 10)
-			schemaRes := v2beta1.KafkaSchema{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "KafkaSchema",
-					APIVersion: "kafka-schema-operator.incubly/v2beta1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:      topicName,
-					Namespace: ResourceNs,
-				},
-				Spec: v2beta1.KafkaSchemaSpec{
-					Name:                  topicName,
-					SchemaSerializer:      "string",
-					AutoReconciliation:    false,
-					TerminationProtection: false,
-					Data: v2beta1.KafkaSchemaData{
-						Schema: `{
-						  "namespace": "testing",
-						  "type": "record",
-						  "name": "testing",
-						  "fields": [
-						    {"name": "id", "type": "string"},
-						    {"name": "email", "type": "string"}
-						  ]
-						}`,
-						Format:        "AVRO",
-						Compatibility: "BACKWARD",
-					},
-				},
-			}
 
 			By("When: creating KafkaSchema resource")
-			ctx := context.Background()
-			Expect(k8sClient.Create(ctx, &schemaRes)).Should(Succeed())
+			Expect(
+				k8sClient.Create(ctx, aKafkaSchemaResource(topicName)),
+			).Should(Succeed())
 
 			By("Then: resource is properly created in K8S")
-			schemaLookupKey := types.NamespacedName{Name: topicName, Namespace: ResourceNs}
-			createdResource := &v2beta1.KafkaSchema{}
-			Eventually(func() error {
-				return k8sClient.Get(ctx, schemaLookupKey, createdResource)
-			}).Should(Succeed())
-
-			Expect(createdResource.Spec.Name).Should(Equal(topicName))
+			Expect(currentResourceState(ctx, topicName).Spec.Name).Should(Equal(topicName))
 			// TODO: verify resource
 
+			// TODO: switch to observing resource status and swap those 2 steps
 			By("And: subjects and schemas for topic key & value are registered in schema registry")
-
-			Eventually(func() map[string]*schemareg_mock.Subject {
-				return srMock.Subjects
-			},
-				time.Second*10,
-				time.Millisecond*100,
-			).Should(
-				And(
-					HaveKey(topicName+"-key"),
-					HaveKey(topicName+"-value"),
-				),
-			)
+			assertSubjectsCreatedInSchemaRegistry(topicName+"-key", topicName+"-value")
 			Expect(srMock.Subjects[topicName+"-value"].SchemaRefs).Should(HaveLen(1))
 			// TODO: verify schema
 
 			By("And: resource are updated with proper status and finalizer")
-			updatedResource := &v2beta1.KafkaSchema{}
-			Eventually(func() error {
-				return k8sClient.Get(ctx, schemaLookupKey, updatedResource)
-			}).Should(Succeed())
-			Expect(updatedResource.Finalizers).Should(ConsistOf("kafka-schema-operator.incubly/finalizer"))
+			Expect(
+				currentResourceState(ctx, topicName).Finalizers,
+			).Should(
+				ConsistOf("kafka-schema-operator.incubly/finalizer"),
+			)
 			// TODO: verify status (& events?)
 		})
 	})
@@ -101,7 +56,56 @@ var _ = Describe("KafkaschemaController", func() {
 		})
 	})
 	Context("When deleting resource", func() {
-		PIt("Should soft-delete subject and cleanup resource", func() {
+		It("Should soft-delete subject and cleanup resource", func() {
+			topicName := "testenv.testservice.testevent." + strconv.FormatInt(time.Now().UnixMilli(), 10)
+			schemaResource := aKafkaSchemaResource(topicName)
+
+			By("Given: KafkaSchema resource was already deployed")
+			Expect(
+				k8sClient.Create(ctx, schemaResource),
+			).Should(Succeed())
+			By("And: controller handled resource creation correctly")
+			// TODO: switch to observing resource status instead of waiting for schema registry
+			assertSubjectsCreatedInSchemaRegistry(topicName+"-key", topicName+"-value")
+
+			By("When: deleting resource")
+			Expect(k8sClient.Delete(ctx, schemaResource)).Should(Succeed())
+
+			By("And: resource is eventually deleted")
+			/*
+				We're waiting for the controller to reconcile the resource
+				(marked for deletion, because it had finalizer - see previous test).
+			*/
+			// TODO: verify the error type & reason
+			Eventually(func() error {
+				return k8sClient.Get(ctx, resourceLookupKey(topicName), &v2beta1.KafkaSchema{})
+			}).ShouldNot(Succeed())
+
+			By("Then: both subjects are soft-deleted from schema registry")
+			Expect(srMock.Subjects).ShouldNot(Or(
+				HaveKey(topicName+"-key"),
+				HaveKey(topicName+"-value")))
 		})
 	})
 })
+
+func assertSubjectsCreatedInSchemaRegistry(subjectNames ...string) {
+	subjectNameMatchers := []types.GomegaMatcher{}
+	for _, subjectName := range subjectNames {
+		subjectNameMatchers = append(subjectNameMatchers, HaveKey(subjectName))
+	}
+	Eventually(func() map[string]*schemareg_mock.Subject {
+		return srMock.Subjects
+	},
+		time.Second*10,
+		time.Millisecond*100,
+	).Should(And(subjectNameMatchers...))
+}
+
+func currentResourceState(ctx context.Context, topicName string) *v2beta1.KafkaSchema {
+	res := &v2beta1.KafkaSchema{}
+	Eventually(func() error {
+		return k8sClient.Get(ctx, resourceLookupKey(topicName), res)
+	}).Should(Succeed())
+	return res
+}

controllers/test_fixture.go

@@ -0,0 +1,45 @@
+package controllers
+
+import (
+	"k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"kafka-schema-operator/api/v2beta1"
+)
+
+const ResourceNs = "default"
+
+func aKafkaSchemaResource(topicName string) *v2beta1.KafkaSchema {
+	return &v2beta1.KafkaSchema{
+		TypeMeta: v1.TypeMeta{
+			Kind:       "KafkaSchema",
+			APIVersion: "kafka-schema-operator.incubly/v2beta1",
+		},
+		ObjectMeta: v1.ObjectMeta{
+			Name:      topicName,
+			Namespace: ResourceNs,
+		},
+		Spec: v2beta1.KafkaSchemaSpec{
+			Name:                  topicName,
+			SchemaSerializer:      "string",
+			AutoReconciliation:    false,
+			TerminationProtection: false,
+			Data: v2beta1.KafkaSchemaData{
+				Schema: `{
+						  "namespace": "testing",
+						  "type": "record",
+						  "name": "testing",
+						  "fields": [
+						    {"name": "id", "type": "string"},
+						    {"name": "email", "type": "string"}
+						  ]
+						}`,
+				Format:        "AVRO",
+				Compatibility: "BACKWARD",
+			},
+		},
+	}
+}
+
+func resourceLookupKey(topicName string) types.NamespacedName {
+	return types.NamespacedName{Name: topicName, Namespace: ResourceNs}
+}