Run e2e tests using a custom type for inventory

Author: mortent

test/e2e/apply_and_destroy_test.go

@@ -9,20 +9,17 @@ import (
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/cli-utils/pkg/apply"
 	"sigs.k8s.io/cli-utils/pkg/apply/event"
-	"sigs.k8s.io/cli-utils/pkg/inventory"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
-func applyAndDestroyTest(c client.Client, inventoryName, namespaceName string) {
+func applyAndDestroyTest(c client.Client, invConfig InventoryConfig, inventoryName, namespaceName string) {
 	By("Apply resources")
-	applier := newApplier()
+	applier := invConfig.ApplierFactoryFunc()
 
-	inv := inventory.WrapInventoryInfoObj(cmInventoryManifest(inventoryName, namespaceName, "test"))
+	inv := invConfig.InvWrapperFunc(invConfig.InventoryFactoryFunc(inventoryName, namespaceName, "test"))
 
 	resources := []*unstructured.Unstructured{
 		deploymentManifest(namespaceName),
@@ -55,18 +52,10 @@ func applyAndDestroyTest(c client.Client, inventoryName, namespaceName string) {
 	Expect(err).ToNot(HaveOccurred())
 
 	By("Verify inventory")
-	var cm v1.ConfigMap
-	err = c.Get(context.TODO(), types.NamespacedName{
-		Name:      inventoryName,
-		Namespace: namespaceName,
-	}, &cm)
-	Expect(err).ToNot(HaveOccurred())
-
-	data := cm.Data
-	Expect(len(data)).To(Equal(1))
+	invConfig.InvSizeVerifyFunc(c, inventoryName, namespaceName, 1)
 
 	By("Destroy resources")
-	destroyer := newDestroyer()
+	destroyer := invConfig.DestroyerFactoryFunc()
 
 	destroyerEvents := runCollectNoErr(destroyer.Run(inv))
 	err = verifyEvents([]expEvent{

test/e2e/common_test.go

@@ -5,8 +5,10 @@ package e2e
 
 import (
 	"fmt"
+	"strings"
 	"time"
 
+	. "github.com/onsi/gomega"
 	appsv1 "k8s.io/api/apps/v1"
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -16,6 +18,7 @@ import (
 	"sigs.k8s.io/cli-utils/pkg/common"
 	"sigs.k8s.io/cli-utils/pkg/kstatus/status"
 	"sigs.k8s.io/cli-utils/pkg/object"
+	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
 func randomString(prefix string) string {
@@ -24,6 +27,26 @@ func randomString(prefix string) string {
 	return fmt.Sprintf("%s%s", prefix, randomSuffix)
 }
 
+func runWithNoErr(ch <-chan event.Event) {
+	runCollectNoErr(ch)
+}
+
+func runCollect(ch <-chan event.Event) []event.Event {
+	var events []event.Event
+	for e := range ch {
+		events = append(events, e)
+	}
+	return events
+}
+
+func runCollectNoErr(ch <-chan event.Event) []event.Event {
+	events := runCollect(ch)
+	for _, e := range events {
+		Expect(e.Type).NotTo(Equal(event.ErrorType))
+	}
+	return events
+}
+
 func cmInventoryManifest(name, namespace, id string) *unstructured.Unstructured {
 	cm := &v1.ConfigMap{
 		TypeMeta: metav1.TypeMeta{
@@ -47,6 +70,21 @@ func cmInventoryManifest(name, namespace, id string) *unstructured.Unstructured
 	}
 }
 
+func customInventoryManifest(name, namespace, id string) *unstructured.Unstructured {
+	u := manifestToUnstructured([]byte(strings.TrimSpace(`
+apiVersion: cli-utils.example.io/v1alpha1
+kind: Inventory
+metadata:
+  name: PLACEHOLDER
+`)))
+	u.SetName(name)
+	u.SetNamespace(namespace)
+	u.SetLabels(map[string]string{
+		common.InventoryLabel: id,
+	})
+	return u
+}
+
 func deploymentManifest(namespace string) *unstructured.Unstructured {
 	dep := &appsv1.Deployment{
 		TypeMeta: metav1.TypeMeta{
@@ -90,6 +128,17 @@ func deploymentManifest(namespace string) *unstructured.Unstructured {
 	}
 }
 
+func manifestToUnstructured(manifest []byte) *unstructured.Unstructured {
+	u := make(map[string]interface{})
+	err := yaml.Unmarshal(manifest, &u)
+	if err != nil {
+		panic(err)
+	}
+	return &unstructured.Unstructured{
+		Object: u,
+	}
+}
+
 func updateReplicas(u *unstructured.Unstructured, replicas int) *unstructured.Unstructured {
 	err := unstructured.SetNestedField(u.Object, int64(replicas), "spec", "replicas")
 	if err != nil {

test/e2e/crd_test.go

@@ -13,18 +13,16 @@ import (
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"sigs.k8s.io/cli-utils/pkg/apply"
 	"sigs.k8s.io/cli-utils/pkg/apply/event"
-	"sigs.k8s.io/cli-utils/pkg/inventory"
 	"sigs.k8s.io/cli-utils/pkg/kstatus/status"
 	"sigs.k8s.io/cli-utils/pkg/object"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
-func crdTest(_ client.Client, inventoryName, namespaceName string) {
+func crdTest(_ client.Client, invConfig InventoryConfig, inventoryName, namespaceName string) {
 	By("apply a set of resources that includes both a crd and a cr")
-	applier := newApplier()
+	applier := invConfig.ApplierFactoryFunc()
 
-	inv := inventory.WrapInventoryInfoObj(cmInventoryManifest(inventoryName, namespaceName, "test"))
+	inv := invConfig.InvWrapperFunc(invConfig.InventoryFactoryFunc(inventoryName, namespaceName, "test"))
 
 	resources := []*unstructured.Unstructured{
 		deploymentManifest(namespaceName),
@@ -79,7 +77,7 @@ func crdTest(_ client.Client, inventoryName, namespaceName string) {
 	Expect(err).ToNot(HaveOccurred())
 
 	By("destroy the resources, including the crd")
-	destroyer := newDestroyer()
+	destroyer := invConfig.DestroyerFactoryFunc()
 	destroyerEvents := runCollectNoErr(destroyer.Run(inv))
 	err = verifyEvents([]expEvent{
 		{
@@ -161,14 +159,3 @@ metadata:
 spec:
   replicas: 4
 `))
-
-func manifestToUnstructured(manifest []byte) *unstructured.Unstructured {
-	u := make(map[string]interface{})
-	err := yaml.Unmarshal(manifest, &u)
-	if err != nil {
-		panic(err)
-	}
-	return &unstructured.Unstructured{
-		Object: u,
-	}
-}

test/e2e/customprovider/provider.go

@@ -0,0 +1,185 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package customprovider
+
+import (
+	"strings"
+
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubectl/pkg/cmd/util"
+	"sigs.k8s.io/cli-utils/pkg/common"
+	"sigs.k8s.io/cli-utils/pkg/inventory"
+	"sigs.k8s.io/cli-utils/pkg/object"
+	"sigs.k8s.io/cli-utils/pkg/provider"
+)
+
+var InventoryCRD = []byte(strings.TrimSpace(`
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: inventories.cli-utils.example.io
+spec:
+  conversion:
+    strategy: None
+  group: cli-utils.example.io
+  names:
+    kind: Inventory
+    listKind: InventoryList
+    plural: inventories
+    singular: inventory
+  scope: Namespaced
+  versions:
+  - name: v1alpha1
+    schema:
+      openAPIV3Schema:
+        description: Example for cli-utils e2e tests
+        properties:
+          apiVersion:
+            type: string
+          kind:
+            type: string
+          metadata:
+            type: object
+          spec:
+            properties:
+              inventory:
+                items:
+                  properties:
+                    group:
+                      type: string
+                    kind:
+                      type: string
+                    name:
+                      type: string
+                    namespace:
+                      type: string
+                  required:
+                  - group
+                  - kind
+                  - name
+                  - namespace
+                  type: object
+                type: array
+            type: object
+        type: object
+    served: true
+    storage: true
+    subresources: {}
+`))
+
+var InventoryGVK = schema.GroupVersionKind{
+	Group:   "cli-utils.example.io",
+	Version: "v1alpha1",
+	Kind:    "Inventory",
+}
+
+var _ provider.Provider = &CustomProvider{}
+
+func NewCustomProvider(f util.Factory) provider.Provider {
+	return &CustomProvider{
+		factory: f,
+	}
+}
+
+type CustomProvider struct {
+	factory util.Factory
+}
+
+func (c *CustomProvider) Factory() util.Factory {
+	return c.factory
+}
+
+func (c *CustomProvider) InventoryClient() (inventory.InventoryClient, error) {
+	return inventory.NewInventoryClient(c.factory, WrapInventoryObj, invToUnstructuredFunc)
+}
+
+func invToUnstructuredFunc(inv inventory.InventoryInfo) *unstructured.Unstructured {
+	switch invInfo := inv.(type) {
+	case *InventoryCustomType:
+		return invInfo.inv
+	default:
+		return nil
+	}
+}
+
+func WrapInventoryObj(obj *unstructured.Unstructured) inventory.Inventory {
+	return &InventoryCustomType{inv: obj}
+}
+
+func WrapInventoryInfoObj(obj *unstructured.Unstructured) inventory.InventoryInfo {
+	return &InventoryCustomType{inv: obj}
+}
+
+var _ inventory.Inventory = &InventoryCustomType{}
+var _ inventory.InventoryInfo = &InventoryCustomType{}
+
+type InventoryCustomType struct {
+	inv *unstructured.Unstructured
+}
+
+func (i InventoryCustomType) Namespace() string {
+	return i.inv.GetNamespace()
+}
+
+func (i InventoryCustomType) Name() string {
+	return i.inv.GetName()
+}
+
+func (i InventoryCustomType) ID() string {
+	labels := i.inv.GetLabels()
+	id, found := labels[common.InventoryLabel]
+	if !found {
+		return ""
+	}
+	return id
+}
+
+func (i InventoryCustomType) Load() ([]object.ObjMetadata, error) {
+	var inv []object.ObjMetadata
+	s, found, err := unstructured.NestedSlice(i.inv.Object, "spec", "inventory")
+	if err != nil {
+		return inv, err
+	}
+	if !found {
+		return inv, nil
+	}
+	for _, item := range s {
+		m := item.(map[string]interface{})
+		namespace, _, _ := unstructured.NestedString(m, "namespace")
+		name, _, _ := unstructured.NestedString(m, "name")
+		group, _, _ := unstructured.NestedString(m, "group")
+		kind, _, _ := unstructured.NestedString(m, "kind")
+		obj, err := object.CreateObjMetadata(namespace, name, schema.GroupKind{
+			Group: group,
+			Kind:  kind,
+		})
+		if err != nil {
+			return inv, err
+		}
+		inv = append(inv, obj)
+	}
+	return inv, nil
+}
+
+func (i InventoryCustomType) Store(objs []object.ObjMetadata) error {
+	var inv []interface{}
+	for _, obj := range objs {
+		inv = append(inv, map[string]interface{}{
+			"group":     obj.GroupKind.Group,
+			"kind":      obj.GroupKind.Kind,
+			"namespace": obj.Namespace,
+			"name":      obj.Name,
+		})
+	}
+	if len(inv) > 0 {
+		return unstructured.SetNestedSlice(i.inv.Object, inv, "spec", "inventory")
+	}
+	unstructured.RemoveNestedField(i.inv.Object, "spec")
+	return nil
+}
+
+func (i InventoryCustomType) GetObject() (*unstructured.Unstructured, error) {
+	return i.inv, nil
+}