fix bug: remove unneeded workload definitions (#1656)

* fix controller

* fix test

e2e/commonContext.go

@@ -141,7 +141,7 @@ var (
 	WorkloadCapabilityListContext = func() bool {
 		return ginkgo.Context("list workload capabilities", func() {
 			ginkgo.It("should sync capabilities from cluster before listing workload capabilities", func() {
-				output, err := Exec("vela workloads")
+				output, err := Exec("vela components")
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 				gomega.Expect(output).To(gomega.ContainSubstring("webservice"))
 			})

pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller.go

@@ -74,12 +74,6 @@ func (r *Reconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) {
 		return ctrl.Result{}, nil
 	}
 
-	handler := handler{
-		Client: r.Client,
-		dm:     r.dm,
-		cd:     &componentDefinition,
-	}
-
 	// refresh package discover when componentDefinition is registered
 	err := utils.RefreshPackageDiscover(ctx, r.Client, r.dm, r.pd, &componentDefinition)
 	if err != nil {
@@ -93,7 +87,7 @@ func (r *Reconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) {
 	defRev, isNewRevision, err := coredef.GenerateDefinitionRevision(ctx, r.Client, &componentDefinition)
 	if err != nil {
 		klog.ErrorS(err, "cannot generate DefinitionRevision", "ComponentDefinitionName", componentDefinition.Name)
-		r.record.Event(handler.cd, event.Warning("cannot generate DefinitionRevision", err))
+		r.record.Event(&componentDefinition, event.Warning("cannot generate DefinitionRevision", err))
 		return ctrl.Result{}, util.PatchCondition(ctx, r, &componentDefinition,
 			cpv1alpha1.ReconcileError(fmt.Errorf(util.ErrGenerateDefinitionRevision, componentDefinition.Name, err)))
 	}
@@ -114,28 +108,7 @@ func (r *Reconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) {
 		return ctrl.Result{}, nil
 	}
 
-	workloadType, err := handler.CreateWorkloadDefinition(ctx)
-	if err != nil {
-		klog.ErrorS(err, "cannot create converted WorkloadDefinition")
-		r.record.Event(&componentDefinition, event.Warning("cannot store capability in ConfigMap", err))
-		return ctrl.Result{}, util.PatchCondition(ctx, r, &componentDefinition,
-			cpv1alpha1.ReconcileError(fmt.Errorf(util.ErrCreateConvertedWorklaodDefinition, componentDefinition.Name, err)))
-	}
-	klog.InfoS("Successfully create WorkloadDefinition", "name", componentDefinition.Name)
-
-	var def utils.CapabilityComponentDefinition
-	def.Name = req.NamespacedName.Name
-	def.WorkloadType = workloadType
-	def.ComponentDefinition = componentDefinition
-	switch workloadType {
-	case util.ReferWorkload:
-		def.WorkloadDefName = componentDefinition.Spec.Workload.Type
-	case util.HELMDef:
-		def.Helm = componentDefinition.Spec.Schematic.HELM
-	case util.KubeDef:
-		def.Kube = componentDefinition.Spec.Schematic.KUBE
-	default:
-	}
+	def := utils.NewCapabilityComponentDef(&componentDefinition)
 
 	// Store the parameter of componentDefinition to configMap
 	err = def.StoreOpenAPISchema(ctx, r.Client, r.pd, req.Namespace, req.Name, defRev.Name)

pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller_test.go

@@ -27,6 +27,7 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	crdv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/utils/pointer"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
@@ -275,7 +276,98 @@ spec:
 		})
 	})
 
-	Context("When the ComponentDefinition is invalid, should hit issues", func() {
+	Context("When the ComponentDefinition contains Helm Module, should create a ConfigMap", func() {
+		var componentDefinitionName = "cd-with-helm-module"
+		var namespace = "default"
+		req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}}
+
+		It("Applying ComponentDefinition with Helm module", func() {
+			cd := v1beta1.ComponentDefinition{}
+			cd.SetName(componentDefinitionName)
+			cd.SetNamespace(namespace)
+			cd.Spec.Workload.Definition = common.WorkloadGVK{APIVersion: "apps/v1", Kind: "Deployment"}
+			cd.Spec.Schematic = &common.Schematic{
+				HELM: &common.Helm{
+					Release: util.Object2RawExtension(map[string]interface{}{
+						"chart": map[string]interface{}{
+							"spec": map[string]interface{}{
+								"chart":   "podinfo",
+								"version": "5.1.4",
+							},
+						},
+					}),
+					Repository: util.Object2RawExtension(map[string]interface{}{
+						"url": "http://oam.dev/catalog/",
+					}),
+				},
+			}
+			By("Create ComponentDefinition")
+			Expect(k8sClient.Create(ctx, &cd)).Should(Succeed())
+			reconcileRetry(&r, req)
+
+			By("Check whether ConfigMap is created")
+			var cm corev1.ConfigMap
+			name := fmt.Sprintf("%s%s", types.CapabilityConfigMapNamePrefix, componentDefinitionName)
+			Eventually(func() bool {
+				err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, &cm)
+				return err == nil
+			}, 10*time.Second, time.Second).Should(BeTrue())
+			Expect(cm.Data[types.OpenapiV3JSONSchema]).Should(Not(Equal("")))
+
+			By("Check whether ConfigMapRef refer to right ConfigMap")
+			Eventually(func() string {
+				_ = k8sClient.Get(ctx, client.ObjectKey{Namespace: cd.Namespace, Name: cd.Name}, &cd)
+				return cd.Status.ConfigMapRef
+			}, 10*time.Second, time.Second).Should(Equal(name))
+		})
+	})
+
+	Context("When the ComponentDefinition contains Kube Module, should create a ConfigMap", func() {
+		var componentDefinitionName = "cd-with-kube-module"
+		var namespace = "default"
+		req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}}
+
+		It("Applying ComponentDefinition with kube Module", func() {
+			cd := v1beta1.ComponentDefinition{}
+			cd.SetName(componentDefinitionName)
+			cd.SetNamespace(namespace)
+			cd.Spec.Workload.Definition = common.WorkloadGVK{APIVersion: "apps/v1", Kind: "Deployment"}
+			cd.Spec.Schematic = &common.Schematic{
+				KUBE: &common.Kube{
+					Template: generateTemplate(KUBEWorkerTemplate),
+					Parameters: []common.KubeParameter{
+						{
+							Name:        "image",
+							ValueType:   common.StringType,
+							FieldPaths:  []string{"spec.template.spec.containers[0].image"},
+							Required:    pointer.BoolPtr(true),
+							Description: pointer.StringPtr("test description"),
+						},
+					},
+				},
+			}
+			By("Create ComponentDefinition")
+			Expect(k8sClient.Create(ctx, &cd)).Should(Succeed())
+			reconcileRetry(&r, req)
+
+			By("Check whether ConfigMap is created")
+			var cm corev1.ConfigMap
+			name := fmt.Sprintf("%s%s", types.CapabilityConfigMapNamePrefix, componentDefinitionName)
+			Eventually(func() bool {
+				err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, &cm)
+				return err == nil
+			}, 10*time.Second, time.Second).Should(BeTrue())
+			Expect(cm.Data[types.OpenapiV3JSONSchema]).Should(Not(Equal("")))
+
+			By("Check whether ConfigMapRef refer to right ConfigMap")
+			Eventually(func() string {
+				_ = k8sClient.Get(ctx, client.ObjectKey{Namespace: cd.Namespace, Name: cd.Name}, &cd)
+				return cd.Status.ConfigMapRef
+			}, 10*time.Second, time.Second).Should(Equal(name))
+		})
+	})
+
+	Context("When the ComponentDefinition is invalid, should raise errors", func() {
 		var namespace = "ns-def"
 		BeforeEach(func() {
 			ns = corev1.Namespace{
@@ -404,224 +496,6 @@ spec:
 		})
 	})
 
-	Context("When the ComponentDefinition only contains Workload.Definition, should create a WorkloadDefinition", func() {
-		var componentDefinitionName = "cd-with-workload-definition"
-		var namespace = "default"
-		req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}}
-
-		It("Applying ComponentDefinition with Workload.Definition", func() {
-			By("Apply ComponentDefinition")
-			var validComponentDefinition = `
-apiVersion: core.oam.dev/v1beta1
-kind: ComponentDefinition
-metadata:
-  name: cd-with-workload-definition
-  annotations:
-    definition.oam.dev/description: "test"
-spec:
-  workload:
-    definition:
-      apiVersion: apps/v1
-      kind: Deployment
-  schematic:
-    cue:
-      template: |
-        output: {
-        	apiVersion: "apps/v1"
-        	kind:       "Deployment"
-        	spec: {
-        		selector: matchLabels: {
-        			"app.oam.dev/component": context.name
-        		}
-
-        		template: {
-        			metadata: labels: {
-        				"app.oam.dev/component": context.name
-        			}
-
-        			spec: {
-        				containers: [{
-        					name:  context.name
-        					image: parameter.image
-
-        					if parameter["cmd"] != _|_ {
-        						command: parameter.cmd
-        					}
-        				}]
-        			}
-        		}
-        	}
-        }
-        parameter: {
-        	// +usage=Which image would you like to use for your service
-        	// +short=i
-        	image: string
-
-        	// +usage=Commands to run in the container
-        	cmd?: [...string]
-        }
-`
-			var def v1beta1.ComponentDefinition
-			Expect(yaml.Unmarshal([]byte(validComponentDefinition), &def)).Should(BeNil())
-			def.Namespace = namespace
-			Expect(k8sClient.Create(ctx, &def)).Should(Succeed())
-			reconcileRetry(&r, req)
-			By("Check whether WorkloadDefinition is created")
-
-			var wd v1beta1.WorkloadDefinition
-			var wdName = componentDefinitionName
-			Eventually(func() bool {
-				err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: wdName}, &wd)
-				return err == nil
-			}, 10*time.Second, time.Second).Should(BeTrue())
-			Expect(wd.Name).Should(Equal(def.Name))
-			Expect(wd.Namespace).Should(Equal(def.Namespace))
-			Expect(wd.Annotations).Should(Equal(def.Annotations))
-			Expect(wd.Spec.Schematic).Should(Equal(def.Spec.Schematic))
-		})
-	})
-
-	Context("When the ComponentDefinition contains Helm schematic", func() {
-		var componentDefinitionName = "cd-with-helm-schematic"
-		var namespace = "default"
-		req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}}
-
-		It("Applying ComponentDefinition with Helm schematic", func() {
-			cd := v1beta1.ComponentDefinition{}
-			cd.SetName(componentDefinitionName)
-			cd.SetNamespace(namespace)
-			cd.Spec.Workload.Definition = common.WorkloadGVK{APIVersion: "apps/v1", Kind: "Deployment"}
-			cd.Spec.Schematic = &common.Schematic{
-				HELM: &common.Helm{
-					Release: util.Object2RawExtension(map[string]interface{}{
-						"chart": map[string]interface{}{
-							"spec": map[string]interface{}{
-								"chart":   "podinfo",
-								"version": "5.1.4",
-							},
-						},
-					}),
-					Repository: util.Object2RawExtension(map[string]interface{}{
-						"url": "http://oam.dev/catalog/",
-					}),
-				},
-			}
-			By("Create ComponentDefinition")
-			Expect(k8sClient.Create(ctx, &cd)).Should(Succeed())
-			reconcileRetry(&r, req)
-
-			By("Check whether WorkloadDefinition is created")
-			var wd v1beta1.WorkloadDefinition
-			var wdName = componentDefinitionName
-			Eventually(func() bool {
-				err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: wdName}, &wd)
-				return err == nil
-			}, 10*time.Second, time.Second).Should(BeTrue())
-			Expect(wd.Name).Should(Equal(cd.Name))
-			Expect(wd.Namespace).Should(Equal(cd.Namespace))
-			Expect(wd.Annotations).Should(Equal(cd.Annotations))
-			Expect(wd.Spec.Schematic).Should(Equal(cd.Spec.Schematic))
-		})
-	})
-
-	Context("When the ComponentDefinition contain Workload.Type, shouldn't create a WorkloadDefinition", func() {
-		var componentDefinitionName = "cd-with-workload-type"
-		var namespace = "default"
-		req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}}
-
-		It("Applying ComponentDefinition with Workload.Type", func() {
-			By("Apply WorkloadDefinition")
-			var taskWorkloadDefinition = `
-apiVersion: core.oam.dev/v1beta1
-kind: WorkloadDefinition
-metadata:
-  name: worker
-  annotations:
-    definition.oam.dev/description: "Describes long-running, scalable, containerized services that running at backend. They do NOT have network endpoint to receive external network traffic."
-spec:
-  definitionRef:
-    name: deployments.apps
-  schematic:
-    cue:
-      template: |
-        output: {
-        	apiVersion: "apps/v1"
-        	kind:       "Deployment"
-        	spec: {
-        		selector: matchLabels: {
-        			"app.oam.dev/component": context.name
-        		}
-        
-        		template: {
-        			metadata: labels: {
-        				"app.oam.dev/component": context.name
-        			}
-        
-        			spec: {
-        				containers: [{
-        					name:  context.name
-        					image: parameter.image
-        
-        					if parameter["cmd"] != _|_ {
-        						command: parameter.cmd
-        					}
-        				}]
-        			}
-        		}
-        	}
-        }
-        
-        parameter: {
-        	// +usage=Which image would you like to use for your service
-        	// +short=i
-        	image: string
-        	// +usage=Commands to run in the container
-        	cmd?: [...string]
-        }
-`
-			var task v1beta1.WorkloadDefinition
-			Expect(yaml.Unmarshal([]byte(taskWorkloadDefinition), &task)).Should(BeNil())
-			task.Namespace = namespace
-			Expect(k8sClient.Create(ctx, &task)).Should(Succeed())
-
-			By("Apply ComponentDefinition")
-			var validComponentDefinition = `
-apiVersion: core.oam.dev/v1beta1
-kind: ComponentDefinition
-metadata:
-  name: cd-with-workload-type
-spec:
-  workload:
-    type: worker
-`
-			var def v1beta1.ComponentDefinition
-			Expect(yaml.Unmarshal([]byte(validComponentDefinition), &def)).Should(BeNil())
-			def.Namespace = namespace
-			Expect(k8sClient.Create(ctx, &def)).Should(Succeed())
-
-			By("Check whether WorkloadDefinition is created")
-			reconcileRetry(&r, req)
-			var wd v1beta1.WorkloadDefinition
-			var wdName = componentDefinitionName
-			Expect(k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: wdName}, &wd)).Should(Not(Succeed()))
-
-			By("Check whether ConfigMap is created")
-			var cm corev1.ConfigMap
-			name := fmt.Sprintf("%s%s", types.CapabilityConfigMapNamePrefix, componentDefinitionName)
-			Eventually(func() bool {
-				err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, &cm)
-				return err == nil
-			}, 15*time.Second, time.Second).Should(BeTrue())
-			Expect(cm.Data[types.OpenapiV3JSONSchema]).Should(Not(Equal("")))
-
-			By("Check whether ConfigMapRef refer to right")
-			Eventually(func() string {
-				_ = k8sClient.Get(ctx, client.ObjectKey{Namespace: def.Namespace, Name: def.Name}, &def)
-				return def.Status.ConfigMapRef
-			}, 10*time.Second, time.Second).Should(Equal(name))
-		})
-	})
-
 	Context("When the CUE Template in ComponentDefinition import new added CRD", func() {
 		var componentDefinationName = "test-refresh"
 		var namespace = "default"
@@ -699,24 +573,38 @@ spec:
 			Expect(k8sClient.Create(ctx, &cd)).Should(Succeed())
 			req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinationName, Namespace: namespace}}
 
-			By("check workload")
-			var wd v1beta1.WorkloadDefinition
-			var wdName = componentDefinationName
-			Eventually(func() bool {
-				reconcileRetry(&r, req)
-				err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: wdName}, &wd)
-				return err == nil
-			}, 30*time.Second, time.Second).Should(BeTrue())
-
 			By("Check whether ConfigMap is created")
 			var cm corev1.ConfigMap
 			name := fmt.Sprintf("%s%s", types.CapabilityConfigMapNamePrefix, componentDefinationName)
 			Eventually(func() bool {
+				reconcileRetry(&r, req)
 				err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, &cm)
 				return err == nil
-			}, 15*time.Second, time.Second).Should(BeTrue())
+			}, 30*time.Second, time.Second).Should(BeTrue())
 			Expect(cm.Data[types.OpenapiV3JSONSchema]).Should(Not(Equal("")))
 		})
 
 	})
 })
+
+func generateTemplate(template string) runtime.RawExtension {
+	b, _ := yaml.YAMLToJSON([]byte(template))
+	return runtime.RawExtension{Raw: b}
+}
+
+var KUBEWorkerTemplate = `apiVersion: apps/v1
+kind: Deployment
+spec:
+  selector:
+    matchLabels:
+      app: nginx
+  template:
+    metadata:
+      labels:
+        app: nginx
+    spec:
+      containers:
+      - name: nginx
+      ports:
+      - containerPort: 80
+`

pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/handler.go

@@ -1,84 +0,0 @@
-/*
- Copyright 2021. The KubeVela 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 componentdefinition
-
-import (
-	"context"
-	"fmt"
-
-	kerrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/klog/v2"
-	"k8s.io/utils/pointer"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-
-	"github.com/oam-dev/kubevela/apis/core.oam.dev/common"
-	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1"
-	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
-	"github.com/oam-dev/kubevela/pkg/oam/util"
-)
-
-type handler struct {
-	client.Client
-	dm discoverymapper.DiscoveryMapper
-	cd *v1beta1.ComponentDefinition
-}
-
-func (h *handler) CreateWorkloadDefinition(ctx context.Context) (util.WorkloadType, error) {
-	var workloadType = util.ComponentDef
-	var workloadName = h.cd.Name
-	if h.cd.Spec.Workload.Type != "" && h.cd.Spec.Workload.Definition == (common.WorkloadGVK{}) {
-		workloadType = util.ReferWorkload
-		workloadName = h.cd.Spec.Workload.Type
-	}
-	if h.cd.Spec.Schematic != nil && h.cd.Spec.Schematic.HELM != nil {
-		workloadType = util.HELMDef
-	}
-	if h.cd.Spec.Schematic != nil && h.cd.Spec.Schematic.KUBE != nil {
-		workloadType = util.KubeDef
-	}
-
-	wd := new(v1beta1.WorkloadDefinition)
-	err := h.Get(ctx, client.ObjectKey{Namespace: h.cd.Namespace, Name: workloadName}, wd)
-	if err != nil {
-		switch workloadType {
-		case util.ReferWorkload:
-			klog.Infof("ComponentDefinition %s refer to wrong Workload", h.cd.Name)
-			return workloadType, err
-		default:
-			if !kerrors.IsNotFound(err) {
-				return workloadType, err
-			}
-			newCd := h.cd.DeepCopy()
-			if err := util.ConvertComponentDef2WorkloadDef(h.dm, newCd, wd); err != nil {
-				return workloadType, fmt.Errorf("convert WorkloadDefinition %s error %w", h.cd.Name, err)
-			}
-			owners := []metav1.OwnerReference{{
-				APIVersion: v1beta1.SchemeGroupVersion.String(),
-				Kind:       v1beta1.ComponentDefinitionKind,
-				Name:       h.cd.Name,
-				UID:        h.cd.UID,
-				Controller: pointer.BoolPtr(true),
-			}}
-			wd.SetOwnerReferences(owners)
-			if err := h.Create(ctx, wd); err != nil {
-				return workloadType, fmt.Errorf("create converted WorkloadDefinition %s error %w", h.cd.Name, err)
-			}
-		}
-	}
-	return workloadType, nil
-}

pkg/controller/utils/capability.go

@@ -34,7 +34,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	commontypes "github.com/oam-dev/kubevela/apis/core.oam.dev/common"
-	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1alpha2"
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1"
 	"github.com/oam-dev/kubevela/apis/types"
 	"github.com/oam-dev/kubevela/pkg/appfile"
@@ -67,6 +66,26 @@ type CapabilityComponentDefinition struct {
 	CapabilityBaseDefinition
 }
 
+// NewCapabilityComponentDef will create a CapabilityComponentDefinition
+func NewCapabilityComponentDef(componentDefinition *v1beta1.ComponentDefinition) CapabilityComponentDefinition {
+	var def CapabilityComponentDefinition
+	def.Name = componentDefinition.Name
+	if componentDefinition.Spec.Workload.Definition == (commontypes.WorkloadGVK{}) && componentDefinition.Spec.Workload.Type != "" {
+		def.WorkloadType = util.ReferWorkload
+		def.WorkloadDefName = componentDefinition.Spec.Workload.Type
+	}
+	if componentDefinition.Spec.Schematic != nil && componentDefinition.Spec.Schematic.HELM != nil {
+		def.WorkloadType = util.HELMDef
+		def.Helm = componentDefinition.Spec.Schematic.HELM
+	}
+	if componentDefinition.Spec.Schematic != nil && componentDefinition.Spec.Schematic.KUBE != nil {
+		def.WorkloadType = util.KubeDef
+		def.Kube = componentDefinition.Spec.Schematic.KUBE
+	}
+	def.ComponentDefinition = *componentDefinition.DeepCopy()
+	return def
+}
+
 // GetCapabilityObject gets types.Capability object by WorkloadDefinition name
 func (def *CapabilityComponentDefinition) GetCapabilityObject(ctx context.Context, k8sClient client.Client, namespace, name string) (*types.Capability, error) {
 	var componentDefinition v1beta1.ComponentDefinition
@@ -81,20 +100,11 @@ func (def *CapabilityComponentDefinition) GetCapabilityObject(ctx context.Contex
 	}
 	def.ComponentDefinition = componentDefinition
 
-	switch def.WorkloadType {
-	case util.ReferWorkload:
-		var wd = new(v1alpha2.WorkloadDefinition)
-		objectKey.Name = def.WorkloadDefName
-		if err := k8sClient.Get(ctx, objectKey, wd); err != nil {
-			return nil, fmt.Errorf("failed to get WorkloadDefinition that ComponentDefinition refers to")
-		}
-		capability, err = appfile.ConvertTemplateJSON2Object(name, wd.Spec.Extension, wd.Spec.Schematic)
-	default:
-		capability, err = appfile.ConvertTemplateJSON2Object(name, componentDefinition.Spec.Extension, componentDefinition.Spec.Schematic)
-		if err != nil {
-			return nil, fmt.Errorf("failed to convert ComponentDefinition to Capability Object")
-		}
+	capability, err = appfile.ConvertTemplateJSON2Object(name, componentDefinition.Spec.Extension, componentDefinition.Spec.Schematic)
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert ComponentDefinition to Capability Object")
 	}
+
 	return &capability, err
 }
 

test/e2e-test/app_embed_rollout_test.go

@@ -127,6 +127,11 @@ var _ = Describe("Cloneset based app embed rollout tests", func() {
 
 	AfterEach(func() {
 		By("Clean up resources after a test")
+		k8sClient.DeleteAllOf(ctx, &v1beta1.Application{}, client.InNamespace(namespaceName))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.ComponentDefinition{}, client.InNamespace(namespaceName))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.WorkloadDefinition{}, client.InNamespace(namespaceName))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.TraitDefinition{}, client.InNamespace(namespaceName))
+
 		By(fmt.Sprintf("Delete the entire namespaceName %s", ns.Name))
 		// delete the namespaceName with all its resources
 		Expect(k8sClient.Delete(ctx, &ns, client.PropagationPolicy(metav1.DeletePropagationBackground))).Should(BeNil())

test/e2e-test/app_resourcetracker_test.go

@@ -67,6 +67,11 @@ var _ = Describe("Test application cross namespace resource", func() {
 
 	AfterEach(func() {
 		By("Clean up resources after a test")
+		k8sClient.DeleteAllOf(ctx, &v1beta1.Application{}, client.InNamespace(namespace))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.ComponentDefinition{}, client.InNamespace(namespace))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.WorkloadDefinition{}, client.InNamespace(namespace))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.TraitDefinition{}, client.InNamespace(namespace))
+
 		Expect(k8sClient.Delete(ctx, &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: namespace}}, client.PropagationPolicy(metav1.DeletePropagationForeground))).Should(Succeed())
 		Expect(k8sClient.Delete(ctx, &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: crossNamespace}}, client.PropagationPolicy(metav1.DeletePropagationForeground))).Should(Succeed())
 		// guarantee namespace have been deleted

test/e2e-test/app_revision_clean_up_test.go

@@ -65,6 +65,11 @@ var _ = Describe("Test application controller clean up appRevision", func() {
 
 	AfterEach(func() {
 		By("[TEST] Clean up resources after an integration test")
+		k8sClient.DeleteAllOf(ctx, &v1beta1.Application{}, client.InNamespace(namespace))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.ComponentDefinition{}, client.InNamespace(namespace))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.WorkloadDefinition{}, client.InNamespace(namespace))
+		k8sClient.DeleteAllOf(ctx, &v1beta1.TraitDefinition{}, client.InNamespace(namespace))
+
 		Expect(k8sClient.Delete(ctx, &v1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: namespace}}, client.PropagationPolicy(metav1.DeletePropagationForeground))).Should(Succeed())
 		// guarantee namespace have been deleted
 		Eventually(func() error {

test/e2e-test/definition_revision_test.go

@@ -81,7 +81,7 @@ var _ = Describe("Test application of the specified definition version", func()
 				return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(labelDefRevList.Items))
 			}
 			return nil
-		}, 40*time.Second, time.Second).Should(BeNil())
+		}, 60*time.Second, time.Second).Should(BeNil())
 
 	})
 
@@ -144,7 +144,7 @@ var _ = Describe("Test application of the specified definition version", func()
 				return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(workerDefRevList.Items))
 			}
 			return nil
-		}, 40*time.Second, time.Second).Should(BeNil())
+		}, 60*time.Second, time.Second).Should(BeNil())
 
 		webserviceV1 := webServiceWithNoTemplate.DeepCopy()
 		webserviceV1.Spec.Schematic.CUE.Template = webServiceV1Template
@@ -175,7 +175,7 @@ var _ = Describe("Test application of the specified definition version", func()
 				return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(webserviceDefRevList.Items))
 			}
 			return nil
-		}, 40*time.Second, time.Second).Should(BeNil())
+		}, 60*time.Second, time.Second).Should(BeNil())
 
 		app := v1beta1.Application{
 			ObjectMeta: metav1.ObjectMeta{
@@ -406,7 +406,7 @@ var _ = Describe("Test application of the specified definition version", func()
 				return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(helmworkerDefRevList.Items))
 			}
 			return nil
-		}, 40*time.Second, time.Second).Should(BeNil())
+		}, 60*time.Second, time.Second).Should(BeNil())
 
 		app := v1beta1.Application{
 			ObjectMeta: metav1.ObjectMeta{
@@ -586,7 +586,7 @@ var _ = Describe("Test application of the specified definition version", func()
 				return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(kubeworkerDefRevList.Items))
 			}
 			return nil
-		}, 40*time.Second, time.Second).Should(BeNil())
+		}, 60*time.Second, time.Second).Should(BeNil())
 
 		app := v1beta1.Application{
 			ObjectMeta: metav1.ObjectMeta{

test/e2e-test/definition_test.go

@@ -32,7 +32,7 @@ import (
 	"github.com/oam-dev/kubevela/pkg/oam/util"
 )
 
-var _ = Describe("Test application of the specified definition version", func() {
+var _ = Describe("ComponentDefinition Normal tests", func() {
 	ctx := context.Background()
 
 	var namespace string
@@ -59,7 +59,41 @@ var _ = Describe("Test application of the specified definition version", func()
 	})
 
 	Context("Test dynamic admission control for componentDefinition", func() {
-		It("Test componentDefinition only set definition fields", func() {
+
+		It("Test componentDefinition which only set type field", func() {
+			workDef := &v1beta1.WorkloadDefinition{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "ComponentDefinition",
+					APIVersion: "core.oam.dev/v1beta1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "deployments.apps",
+				},
+				Spec: v1beta1.WorkloadDefinitionSpec{
+					Reference: common.DefinitionReference{
+						Name:    "deployments.apps",
+						Version: "v1",
+					},
+				},
+			}
+			workDef.SetNamespace(namespace)
+			Expect(k8sClient.Create(ctx, workDef)).Should(BeNil())
+
+			cd := webServiceWithNoTemplate.DeepCopy()
+			cd.Spec.Workload.Definition = common.WorkloadGVK{}
+			cd.Spec.Workload.Type = "deployments.apps"
+			cd.SetNamespace(namespace)
+			cd.SetName("test-componentdef")
+			cd.Spec.Schematic.CUE.Template = webServiceV1Template
+			Expect(k8sClient.Create(ctx, cd)).Should(Succeed())
+
+			defRev := new(v1beta1.DefinitionRevision)
+			Eventually(func() error {
+				return k8sClient.Get(ctx, client.ObjectKey{Name: "test-componentdef-v1", Namespace: namespace}, defRev)
+			}).Should(BeNil())
+		})
+
+		It("Test componentDefinition only set definition field", func() {
 			testCd := webServiceWithNoTemplate.DeepCopy()
 			testCd.Spec.Schematic.CUE.Template = webServiceV1Template
 			testCd.SetName("test-componentdef-v1")
@@ -86,30 +120,30 @@ var _ = Describe("Test application of the specified definition version", func()
 		})
 
 		It("Test componentDefinition which definition and type fields are all empty", func() {
-			testCd := webServiceWithNoTemplate.DeepCopy()
-			testCd.SetName("test-componentdef-v2")
-			testCd.Spec.Workload.Definition = common.WorkloadGVK{}
-			testCd.Spec.Schematic.CUE.Template = webServiceV1Template
-			testCd.SetNamespace(namespace)
-			Expect(k8sClient.Create(ctx, testCd)).Should(HaveOccurred())
+			testCd1 := webServiceWithNoTemplate.DeepCopy()
+			testCd1.SetName("test-componentdef-v2")
+			testCd1.Spec.Workload.Definition = common.WorkloadGVK{}
+			testCd1.Spec.Schematic.CUE.Template = webServiceV1Template
+			testCd1.SetNamespace(namespace)
+			Expect(k8sClient.Create(ctx, testCd1)).Should(HaveOccurred())
 		})
 
 		It("Test componentDefinition which definition and type point to same workload type", func() {
-			testCd := webServiceWithNoTemplate.DeepCopy()
-			testCd.SetName("test-componentdef-v3")
-			testCd.Spec.Workload.Type = "deployments.apps"
-			testCd.Spec.Schematic.CUE.Template = webServiceV1Template
-			testCd.SetNamespace(namespace)
-			Expect(k8sClient.Create(ctx, testCd)).Should(Succeed())
+			testCd2 := webServiceWithNoTemplate.DeepCopy()
+			testCd2.SetName("test-componentdef-v3")
+			testCd2.Spec.Workload.Type = "deployments.apps"
+			testCd2.Spec.Schematic.CUE.Template = webServiceV1Template
+			testCd2.SetNamespace(namespace)
+			Expect(k8sClient.Create(ctx, testCd2)).Should(Succeed())
 		})
 
 		It("Test componentDefinition which definition and type point to different workload type", func() {
-			testCd := webServiceWithNoTemplate.DeepCopy()
-			testCd.SetName("test-componentdef-v4")
-			testCd.Spec.Workload.Type = "jobs.batch"
-			testCd.Spec.Schematic.CUE.Template = webServiceV1Template
-			testCd.SetNamespace(namespace)
-			Expect(k8sClient.Create(ctx, testCd)).Should(HaveOccurred())
+			testCd3 := webServiceWithNoTemplate.DeepCopy()
+			testCd3.SetName("test-componentdef-v4")
+			testCd3.Spec.Workload.Type = "jobs.batch"
+			testCd3.Spec.Schematic.CUE.Template = webServiceV1Template
+			testCd3.SetNamespace(namespace)
+			Expect(k8sClient.Create(ctx, testCd3)).Should(HaveOccurred())
 		})
 	})
 })