cleanup rule e2e test

Signed-off-by: wackxu <xushiwei5@huawei.com>

4 files changed, 111 insertions, 199 deletions

diff --git a/tests/e2e/deployment/device_crd_test.go b/tests/e2e/deployment/device_crd_test.go
index 0805693ce..fb8cd4f60 100644
--- a/tests/e2e/deployment/device_crd_test.go
+++ b/tests/e2e/deployment/device_crd_test.go
@@ -46,7 +46,7 @@ var _ = Describe("Device Management test in E2E scenario", func() {
 
 	BeforeEach(func() {
 		clientSet = utils.NewKubeClient(ctx.Cfg.KubeConfigPath)
-		edgeClientSet = utils.NewKubeEdegClient(ctx.Cfg.KubeConfigPath)
+		edgeClientSet = utils.NewKubeEdgeClient(ctx.Cfg.KubeConfigPath)
 	})
 
 	Context("Test Device Model Creation, Updation and deletion", func() {
diff --git a/tests/e2e/deployment/rule_crd_test.go b/tests/e2e/deployment/rule_crd_test.go
index e5b5e6ca4..fa39203e2 100644
--- a/tests/e2e/deployment/rule_crd_test.go
+++ b/tests/e2e/deployment/rule_crd_test.go
@@ -9,37 +9,35 @@ import (
 	. "github.com/onsi/gomega"
 
 	v1 "github.com/kubeedge/kubeedge/pkg/apis/rules/v1"
+	edgeclientset "github.com/kubeedge/kubeedge/pkg/client/clientset/versioned"
 	"github.com/kubeedge/kubeedge/tests/e2e/utils"
 )
 
-const (
-	RuleEndpointHandler = "/apis/rules.kubeedge.io/v1/namespaces/default/ruleendpoints"
-	RuleHandler         = "/apis/rules.kubeedge.io/v1/namespaces/default/rules"
-)
-
 var _ = Describe("Rule Management test in E2E scenario", func() {
 	var testTimer *utils.TestTimer
 	var testSpecReport SpecReport
+	var edgeClientSet edgeclientset.Interface
+
+	BeforeEach(func() {
+		edgeClientSet = utils.NewKubeEdgeClient(ctx.Cfg.KubeConfigPath)
+	})
+
 	msg := "Hello World!"
 	Context("Test rule and ruleendpoint Creation and deletion", func() {
 		BeforeEach(func() {
 			// Delete any pre-existing rules
-			var ruleList v1.RuleList
-			list, err := utils.GetRuleList(&ruleList, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, nil)
+			list, err := utils.ListRule(edgeClientSet, "default")
 			Expect(err).To(BeNil())
 			for _, rule := range list {
-				IsRuleDeleted, statusCode := utils.HandleRule(http.MethodDelete, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, "/"+rule.Name, "", "")
-				Expect(IsRuleDeleted).Should(BeTrue())
-				Expect(statusCode).Should(Equal(http.StatusOK))
+				err := utils.HandleRule(edgeClientSet, http.MethodDelete, rule.Name, "", "")
+				Expect(err).To(BeNil())
 			}
 			// Delete any pre-existing ruleendpoints
-			var ruleEndpointList v1.RuleEndpointList
-			reList, err := utils.GetRuleEndpointList(&ruleEndpointList, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, nil)
+			reList, err := utils.ListRuleEndpoint(edgeClientSet, "default")
 			Expect(err).To(BeNil())
 			for _, ruleendpoint := range reList {
-				IsReDeleted, statusCode := utils.HandleRule(http.MethodDelete, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "/"+ruleendpoint.Name, "", "")
-				Expect(IsReDeleted).Should(BeTrue())
-				Expect(statusCode).Should(Equal(http.StatusOK))
+				err := utils.HandleRule(edgeClientSet, http.MethodDelete, ruleendpoint.Name, "", "")
+				Expect(err).To(BeNil())
 			}
 			// Get current test SpecReport
 			testSpecReport = CurrentSpecReport()
@@ -51,44 +49,40 @@ var _ = Describe("Rule Management test in E2E scenario", func() {
 			testTimer.End()
 			// Print result
 			testTimer.PrintResult()
-			// Delete the rules created
-			var ruleList v1.RuleList
-			list, err := utils.GetRuleList(&ruleList, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, nil)
+			list, err := utils.ListRule(edgeClientSet, "default")
 			Expect(err).To(BeNil())
 			for _, rule := range list {
-				IsRuleDeleted, statusCode := utils.HandleRule(http.MethodDelete, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, "/"+rule.Name, "", "")
-				Expect(IsRuleDeleted).Should(BeTrue())
-				Expect(statusCode).Should(Equal(http.StatusOK))
+				err := utils.HandleRule(edgeClientSet, http.MethodDelete, rule.Name, "", "")
+				Expect(err).To(BeNil())
 			}
 			// Delete ruleendpoints
-			var ruleEndpointList v1.RuleEndpointList
-			reList, err := utils.GetRuleEndpointList(&ruleEndpointList, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, nil)
+			reList, err := utils.ListRuleEndpoint(edgeClientSet, "default")
 			Expect(err).To(BeNil())
 			for _, ruleendpoint := range reList {
-				IsReDeleted, statusCode := utils.HandleRule(http.MethodDelete, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "/"+ruleendpoint.Name, "", "")
-				Expect(IsReDeleted).Should(BeTrue())
-				Expect(statusCode).Should(Equal(http.StatusOK))
+				err := utils.HandleRuleEndpoint(edgeClientSet, http.MethodDelete, ruleendpoint.Name, "")
+				Expect(err).To(BeNil())
 			}
 
 			utils.PrintTestcaseNameandStatus()
 		})
 		It("E2E_CREATE_RULE_1: Create rule: rest to eventbus.", func() {
-			var ruleList v1.RuleList
 			// create rest ruleendpoint
-			IsRestRuleEndpointCreated, status := utils.HandleRuleEndpoint(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "", v1.RuleEndpointTypeRest)
-			Expect(IsRestRuleEndpointCreated).Should(BeTrue())
-			Expect(status).Should(Equal(http.StatusCreated))
+			err := utils.HandleRuleEndpoint(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeRest)
+			Expect(err).To(BeNil())
 			// create eventbus ruleendpoint
-			IsEventbusRuleEndpointCreated, status := utils.HandleRuleEndpoint(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "", v1.RuleEndpointTypeEventBus)
-			Expect(IsEventbusRuleEndpointCreated).Should(BeTrue())
-			Expect(status).Should(Equal(http.StatusCreated))
+			err = utils.HandleRuleEndpoint(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeEventBus)
+			Expect(err).To(BeNil())
 			// create rule: rest to eventbus.
-			IsRuleCreated, statusCode := utils.HandleRule(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, "", v1.RuleEndpointTypeRest, v1.RuleEndpointTypeEventBus)
-			Expect(IsRuleCreated).Should(BeTrue())
-			Expect(statusCode).Should(Equal(http.StatusCreated))
+			err = utils.HandleRule(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeRest, v1.RuleEndpointTypeEventBus)
+			Expect(err).To(BeNil())
+
 			newRule := utils.NewRule(v1.RuleEndpointTypeRest, v1.RuleEndpointTypeEventBus)
-			_, err := utils.GetRuleList(&ruleList, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, newRule)
+			ruleList, err := utils.ListRule(edgeClientSet, "default")
+			Expect(err).To(BeNil())
+
+			err = utils.CheckRuleExists(ruleList, newRule)
 			Expect(err).To(BeNil())
+
 			b := new(bytes.Buffer)
 			go func() {
 				receiveMsg, err := utils.SubscribeMqtt("topic-test")
@@ -108,17 +102,14 @@ var _ = Describe("Rule Management test in E2E scenario", func() {
 			}, "30s", "2s").Should(Equal(true), "eventbus not subscribe anything.")
 		})
 		It("E2E_CREATE_RULE_2: Create rule: eventbus to rest.", func() {
-			IsRestRuleEndpointCreated, status := utils.HandleRuleEndpoint(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "", v1.RuleEndpointTypeRest)
-			Expect(IsRestRuleEndpointCreated).Should(BeTrue())
-			Expect(status).Should(Equal(http.StatusCreated))
+			err := utils.HandleRuleEndpoint(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeRest)
+			Expect(err).To(BeNil())
 			// create eventbus ruleendpoint
-			IsEventbusRuleEndpointCreated, status := utils.HandleRuleEndpoint(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "", v1.RuleEndpointTypeEventBus)
-			Expect(IsEventbusRuleEndpointCreated).Should(BeTrue())
-			Expect(status).Should(Equal(http.StatusCreated))
+			err = utils.HandleRuleEndpoint(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeEventBus)
+			Expect(err).To(BeNil())
 			// create rule: eventbus to rest.
-			IsRuleCreated, statusCode := utils.HandleRule(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, "", v1.RuleEndpointTypeEventBus, v1.RuleEndpointTypeRest)
-			Expect(IsRuleCreated).Should(BeTrue())
-			Expect(statusCode).Should(Equal(http.StatusCreated))
+			err = utils.HandleRule(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeEventBus, v1.RuleEndpointTypeRest)
+			Expect(err).To(BeNil())
 			b := new(bytes.Buffer)
 			go func() {
 				receiveMsg, err := utils.StartEchoServer()
@@ -129,28 +120,30 @@ var _ = Describe("Rule Management test in E2E scenario", func() {
 			}()
 			time.Sleep(3 * time.Second)
 			// call rest api to send message to edge.
-			err := utils.PublishMqtt("default/test", msg)
+			err = utils.PublishMqtt("default/test", msg)
 			Expect(err).Should(BeNil())
 			Eventually(func() bool {
 				return b.String() == msg
 			}, "30s", "2s").Should(Equal(true), "endpoint not listen any request.")
 		})
 		It("E2E_CREATE_RULE_3: Create rule: rest to servicebus.", func() {
-			var ruleList v1.RuleList
 			// create rest ruleendpoint
-			IsRestRuleEndpointCreated, status := utils.HandleRuleEndpoint(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "", v1.RuleEndpointTypeRest)
-			Expect(IsRestRuleEndpointCreated).Should(BeTrue())
-			Expect(status).Should(Equal(http.StatusCreated))
+			err := utils.HandleRuleEndpoint(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeRest)
+			Expect(err).To(BeNil())
 			// create servicebus ruleendpoint
-			IsServicebusRuleEndpointCreated, status := utils.HandleRuleEndpoint(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "", v1.RuleEndpointTypeServiceBus)
-			Expect(IsServicebusRuleEndpointCreated).Should(BeTrue())
-			Expect(status).Should(Equal(http.StatusCreated))
+			err = utils.HandleRuleEndpoint(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeServiceBus)
+			Expect(err).To(BeNil())
 			// create rule: rest to servicebus
-			IsRuleCreated, statusCode := utils.HandleRule(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, "", v1.RuleEndpointTypeRest, v1.RuleEndpointTypeServiceBus)
-			Expect(IsRuleCreated).Should(BeTrue())
-			Expect(statusCode).Should(Equal(http.StatusCreated))
+			err = utils.HandleRule(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeRest, v1.RuleEndpointTypeServiceBus)
+			Expect(err).To(BeNil())
 			newRule := utils.NewRule(v1.RuleEndpointTypeRest, v1.RuleEndpointTypeServiceBus)
-			_, err := utils.GetRuleList(&ruleList, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, newRule)
+
+			ruleList, err := utils.ListRule(edgeClientSet, "default")
+			Expect(err).To(BeNil())
+
+			err = utils.CheckRuleExists(ruleList, newRule)
+			Expect(err).To(BeNil())
+
 			Expect(err).To(BeNil())
 			msgHeader := map[string]string{
 				"user":   "I am user",
@@ -179,17 +172,14 @@ var _ = Describe("Rule Management test in E2E scenario", func() {
 		It("E2E_CREATE_RULE_4: Create rule: servicebus to rest.", func() {
 			r := "Hello World"
 			// create rest ruleendpoint
-			IsRestRuleEndpointCreated, status := utils.HandleRuleEndpoint(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "", v1.RuleEndpointTypeRest)
-			Expect(IsRestRuleEndpointCreated).Should(BeTrue())
-			Expect(status).Should(Equal(http.StatusCreated))
+			err := utils.HandleRuleEndpoint(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeRest)
+			Expect(err).To(BeNil())
 			// create servicebus ruleendpoint
-			IsServicebusRuleEndpointCreated, status := utils.HandleRuleEndpoint(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleEndpointHandler, "", v1.RuleEndpointTypeServiceBus)
-			Expect(IsServicebusRuleEndpointCreated).Should(BeTrue())
-			Expect(status).Should(Equal(http.StatusCreated))
+			err = utils.HandleRuleEndpoint(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeServiceBus)
+			Expect(err).To(BeNil())
 			// create rule: servicebus to rest
-			IsRuleCreated, statusCode := utils.HandleRule(http.MethodPost, ctx.Cfg.K8SMasterForKubeEdge+RuleHandler, "", v1.RuleEndpointTypeServiceBus, v1.RuleEndpointTypeRest)
-			Expect(IsRuleCreated).Should(BeTrue())
-			Expect(statusCode).Should(Equal(http.StatusCreated))
+			err = utils.HandleRule(edgeClientSet, http.MethodPost, "", v1.RuleEndpointTypeServiceBus, v1.RuleEndpointTypeRest)
+			Expect(err).To(BeNil())
 			b := new(bytes.Buffer)
 			go func() {
 				receiveMsg, err := utils.StartEchoServer()
diff --git a/tests/e2e/utils/pod.go b/tests/e2e/utils/pod.go
index cb7034712..3670147d7 100644
--- a/tests/e2e/utils/pod.go
+++ b/tests/e2e/utils/pod.go
@@ -124,8 +124,8 @@ func NewKubeClient(kubeConfigPath string) clientset.Interface {
 	return kubeClient
 }
 
-// NewKubeEdegClient creates kubeEdge CRD client from config
-func NewKubeEdegClient(kubeConfigPath string) edgeclientset.Interface {
+// NewKubeEdgeClient creates kubeEdge CRD client from config
+func NewKubeEdgeClient(kubeConfigPath string) edgeclientset.Interface {
 	kubeConfig, err := clientcmd.BuildConfigFromFlags("", kubeConfigPath)
 	if err != nil {
 		Fatalf("Get kube config failed with error: %v", err)
diff --git a/tests/e2e/utils/rule.go b/tests/e2e/utils/rule.go
index 48d961156..291291cec 100644
--- a/tests/e2e/utils/rule.go
+++ b/tests/e2e/utils/rule.go
@@ -1,18 +1,16 @@
 package utils
 
 import (
-	"bytes"
-	"crypto/tls"
-	"encoding/json"
+	"context"
 	"errors"
-	"io"
 	"net/http"
 	"reflect"
-	"time"
 
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	rulesv1 "github.com/kubeedge/kubeedge/pkg/apis/rules/v1"
+	edgeclientset "github.com/kubeedge/kubeedge/pkg/client/clientset/versioned"
 )
 
 func NewRule(sourceType, targetType rulesv1.RuleEndpointTypeDef) *rulesv1.Rule {
@@ -204,155 +202,79 @@ func newServiceBusRuleEndpoint() *rulesv1.RuleEndpoint {
 	return &servicebusRuleEndpoint
 }
 
-// GetRuleList to get the rule list and verify whether the contents of the rule matches with what is expected
-func GetRuleList(list *rulesv1.RuleList, getRuleAPI string, expectedRule *rulesv1.Rule) ([]rulesv1.Rule, error) {
-	resp, err := SendHTTPRequest(http.MethodGet, getRuleAPI)
-	defer resp.Body.Close()
-	contents, err := io.ReadAll(resp.Body)
+func ListRule(c edgeclientset.Interface, ns string) ([]rulesv1.Rule, error) {
+	rules, err := c.RulesV1().Rules(ns).List(context.TODO(), v1.ListOptions{})
 	if err != nil {
-		Fatalf("HTTP Response reading has failed: %v", err)
 		return nil, err
 	}
-	err = json.Unmarshal(contents, &list)
-	if err != nil {
-		Fatalf("Unmarshal HTTP Response has failed: %v", err)
-		return nil, err
-	}
-	if expectedRule != nil {
-		modelExists := false
-		for _, rule := range list.Items {
-			if expectedRule.ObjectMeta.Name == rule.ObjectMeta.Name {
-				modelExists = true
-				if !reflect.DeepEqual(expectedRule.TypeMeta, rule.TypeMeta) ||
-					expectedRule.ObjectMeta.Namespace != rule.ObjectMeta.Namespace ||
-					!reflect.DeepEqual(expectedRule.Spec, rule.Spec) {
-					return nil, errors.New("the rule is not matching with what was expected")
-				}
-			}
-		}
-		if !modelExists {
-			return nil, errors.New("the requested rule is not found")
-		}
-	}
-	return list.Items, nil
+
+	return rules.Items, nil
 }
 
-// HandleRule to handle rule.
-func HandleRule(operation, apiServer, UID string, sourceType, targetType rulesv1.RuleEndpointTypeDef) (bool, int) {
-	var req *http.Request
-	var err error
-	var body io.Reader
+func CheckRuleExists(rules []rulesv1.Rule, expectedRule *rulesv1.Rule) error {
+	modelExists := false
+	for _, rule := range rules {
+		if expectedRule.ObjectMeta.Name != rule.ObjectMeta.Name {
+			continue
+		}
 
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		modelExists = true
+		if !reflect.DeepEqual(expectedRule.TypeMeta, rule.TypeMeta) ||
+			expectedRule.ObjectMeta.Namespace != rule.ObjectMeta.Namespace ||
+			!reflect.DeepEqual(expectedRule.Spec, rule.Spec) {
+			return errors.New("the rule is not matching with what was expected")
+		}
+		break
 	}
-	client := &http.Client{
-		Transport: tr,
+	if !modelExists {
+		return errors.New("the requested rule is not found")
 	}
 
+	return nil
+}
+
+// HandleRule to handle rule.
+func HandleRule(c edgeclientset.Interface, operation, UID string, sourceType, targetType rulesv1.RuleEndpointTypeDef) error {
 	switch operation {
 	case http.MethodPost:
 		body := NewRule(sourceType, targetType)
-		respBytes, err := json.Marshal(body)
-		if err != nil {
-			Fatalf("Marshalling body failed: %v", err)
-		}
-		req, err = http.NewRequest(http.MethodPost, apiServer, bytes.NewBuffer(respBytes))
-		req.Header.Set("Content-Type", "application/json")
+		_, err := c.RulesV1().Rules("default").Create(context.TODO(), body, v1.CreateOptions{})
+		return err
+
 	case http.MethodDelete:
-		req, err = http.NewRequest(http.MethodDelete, apiServer+UID, body)
-		req.Header.Set("Content-Type", "application/json")
-	}
-	if err != nil {
-		// handle error
-		Fatalf("Frame HTTP request failed: %v", err)
-		return false, 0
-	}
-	t := time.Now()
-	resp, err := client.Do(req)
-	if err != nil {
-		// handle error
-		Fatalf("HTTP request is failed :%v", err)
-		return false, 0
+		err := c.RulesV1().Rules("default").Delete(context.TODO(), UID, v1.DeleteOptions{})
+		if err != nil && apierrors.IsNotFound(err) {
+			return nil
+		}
+		return err
 	}
-	defer resp.Body.Close()
-	contents, err := io.ReadAll(resp.Body)
-	Infof("%s %s %v  %v in %v", req.Method, req.URL, resp.Status, string(contents), time.Since(t))
-	return true, resp.StatusCode
+
+	return nil
 }
 
 // HandleRuleEndpoint to handle ruleendpoint.
-func HandleRuleEndpoint(operation string, apiServer string, UID string, endpointType rulesv1.RuleEndpointTypeDef) (bool, int) {
-	var req *http.Request
-	var err error
-	var body io.Reader
-
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-	client := &http.Client{
-		Transport: tr,
-	}
-
+func HandleRuleEndpoint(c edgeclientset.Interface, operation string, UID string, endpointType rulesv1.RuleEndpointTypeDef) error {
 	switch operation {
 	case http.MethodPost:
 		body := NewRuleEndpoint(endpointType)
-		respBytes, err := json.Marshal(body)
-		if err != nil {
-			Fatalf("Marshalling body failed: %v", err)
-		}
-		req, err = http.NewRequest(http.MethodPost, apiServer, bytes.NewBuffer(respBytes))
-		req.Header.Set("Content-Type", "application/json")
+		_, err := c.RulesV1().RuleEndpoints("default").Create(context.TODO(), body, v1.CreateOptions{})
+		return err
+
 	case http.MethodDelete:
-		req, err = http.NewRequest(http.MethodDelete, apiServer+UID, body)
-		req.Header.Set("Content-Type", "application/json")
-	}
-	if err != nil {
-		// handle error
-		Fatalf("Frame HTTP request failed: %v", err)
-		return false, 0
-	}
-	t := time.Now()
-	resp, err := client.Do(req)
-	if err != nil {
-		// handle error
-		Fatalf("HTTP request is failed :%v", err)
-		return false, 0
+		err := c.RulesV1().RuleEndpoints("default").Delete(context.TODO(), UID, v1.DeleteOptions{})
+		if err != nil && apierrors.IsNotFound(err) {
+			return nil
+		}
+		return err
 	}
-	defer resp.Body.Close()
-	Infof("%s %s %v in %v", req.Method, req.URL, resp.Status, time.Since(t))
-	return true, resp.StatusCode
+	return nil
 }
 
-// GetRuleEndpointList to get the rule endpoint list and verify whether the contents of the ruleendpoint matches with what is expected
-func GetRuleEndpointList(list *rulesv1.RuleEndpointList, getRuleEndpointAPI string, expectedRule *rulesv1.RuleEndpoint) ([]rulesv1.RuleEndpoint, error) {
-	resp, err := SendHTTPRequest(http.MethodGet, getRuleEndpointAPI)
-	defer resp.Body.Close()
-	contents, err := io.ReadAll(resp.Body)
-	if err != nil {
-		Fatalf("HTTP Response reading has failed: %v", err)
-		return nil, err
-	}
-	err = json.Unmarshal(contents, &list)
+func ListRuleEndpoint(c edgeclientset.Interface, ns string) ([]rulesv1.RuleEndpoint, error) {
+	rules, err := c.RulesV1().RuleEndpoints(ns).List(context.TODO(), v1.ListOptions{})
 	if err != nil {
-		Fatalf("Unmarshal HTTP Response has failed: %v", err)
 		return nil, err
 	}
-	if expectedRule != nil {
-		exists := false
-		for _, ruleEndpoint := range list.Items {
-			if expectedRule.ObjectMeta.Name == ruleEndpoint.ObjectMeta.Name {
-				exists = true
-				if !reflect.DeepEqual(expectedRule.TypeMeta, ruleEndpoint.TypeMeta) ||
-					expectedRule.ObjectMeta.Namespace != ruleEndpoint.ObjectMeta.Namespace ||
-					!reflect.DeepEqual(expectedRule.Spec, ruleEndpoint.Spec) {
-					return nil, errors.New("the ruleendpoint is not matching with what was expected")
-				}
-			}
-		}
-		if !exists {
-			return nil, errors.New("the requested ruleendpoint is not found")
-		}
-	}
-	return list.Items, nil
+
+	return rules.Items, nil
 }