Merge pull request #4983 from cl2017/device_v1beta1_api

device crd v1beta1 and API definition

3 files changed, 137 insertions, 2186 deletions

diff --git a/tests/e2e/device/device.go b/tests/e2e/device/device.go
index 80d57cf7f..955921ecd 100644
--- a/tests/e2e/device/device.go
+++ b/tests/e2e/device/device.go
@@ -17,15 +17,11 @@ limitations under the License.
 package device
 
 import (
-	"context"
 	"net/http"
 	"time"
 
 	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/kubernetes/test/e2e/framework"
 
 	edgeclientset "github.com/kubeedge/kubeedge/pkg/client/clientset/versioned"
@@ -41,11 +37,9 @@ const (
 var _ = GroupDescribe("Device Management test in E2E scenario", func() {
 	var testTimer *utils.TestTimer
 	var testSpecReport ginkgo.GinkgoTestDescription
-	var clientSet clientset.Interface
 	var edgeClientSet edgeclientset.Interface
 
 	ginkgo.BeforeEach(func() {
-		clientSet = utils.NewKubeClient(framework.TestContext.KubeConfig)
 		edgeClientSet = utils.NewKubeEdgeClient(framework.TestContext.KubeConfig)
 	})
 
@@ -77,28 +71,8 @@ var _ = GroupDescribe("Device Management test in E2E scenario", func() {
 			}
 			utils.PrintTestcaseNameandStatus()
 		})
-		framework.ConformanceIt("E2E_CREATE_DEVICE_MODEL_1: Create device model for LED device (No Protocol)", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			newLedDeviceModel := utils.NewLedDeviceModel()
-
-			deviceModelList, err := utils.ListDeviceModel(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			gomega.Expect(utils.CheckDeviceModelExists(deviceModelList, &newLedDeviceModel)).To(gomega.BeNil())
-		})
-		framework.ConformanceIt("E2E_CREATE_DEVICE_MODEL_2: Create device model for bluetooth protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "bluetooth")
-			gomega.Expect(err).To(gomega.BeNil())
-			newBluetoothDeviceModel := utils.NewBluetoothDeviceModel()
-
-			deviceModelList, err := utils.ListDeviceModel(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			gomega.Expect(utils.CheckDeviceModelExists(deviceModelList, &newBluetoothDeviceModel)).To(gomega.BeNil())
-		})
-		framework.ConformanceIt("E2E_CREATE_DEVICE_MODEL_3: Create device model for modbus protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "modbus")
+		framework.ConformanceIt("E2E_CREATE_DEVICE_MODEL_1: Create device model for modbus protocol", func() {
+			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
 			newModbusDeviceMode := utils.NewModbusDeviceModel()
 
@@ -107,34 +81,10 @@ var _ = GroupDescribe("Device Management test in E2E scenario", func() {
 
 			gomega.Expect(utils.CheckDeviceModelExists(deviceModelList, &newModbusDeviceMode)).To(gomega.BeNil())
 		})
-		framework.ConformanceIt("E2E_UPDATE_DEVICE_MODEL_1: Update device model for LED device (No Protocol)", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceModel(edgeClientSet, http.MethodPatch, utils.UpdatedLedDeviceModel().Name, "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			updatedLedDeviceModel := utils.UpdatedLedDeviceModel()
-
-			deviceModelList, err := utils.ListDeviceModel(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			gomega.Expect(utils.CheckDeviceModelExists(deviceModelList, &updatedLedDeviceModel)).To(gomega.BeNil())
-		})
-		framework.ConformanceIt("E2E_UPDATE_DEVICE_MODEL_2: Update device model for bluetooth protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "bluetooth")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceModel(edgeClientSet, http.MethodPatch, utils.UpdatedBluetoothDeviceModel().Name, "bluetooth")
-			gomega.Expect(err).To(gomega.BeNil())
-			updatedBluetoothDeviceModel := utils.UpdatedBluetoothDeviceModel()
-
-			deviceModelList, err := utils.ListDeviceModel(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			gomega.Expect(utils.CheckDeviceModelExists(deviceModelList, &updatedBluetoothDeviceModel)).To(gomega.BeNil())
-		})
-		framework.ConformanceIt("E2E_UPDATE_DEVICE_MODEL_3: Update device model for modbus protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "modbus")
+		framework.ConformanceIt("E2E_UPDATE_DEVICE_MODEL_1: Update device model for modbus protocol", func() {
+			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceModel(edgeClientSet, http.MethodPatch, utils.UpdatedModbusDeviceModel().Name, "modbus")
+			err = utils.HandleDeviceModel(edgeClientSet, http.MethodPatch, utils.UpdatedModbusDeviceModel().Name, utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
 			updatedModbusDeviceModel := utils.UpdatedModbusDeviceModel()
 			deviceModelList, err := utils.ListDeviceModel(edgeClientSet, "default")
@@ -142,14 +92,14 @@ var _ = GroupDescribe("Device Management test in E2E scenario", func() {
 
 			gomega.Expect(utils.CheckDeviceModelExists(deviceModelList, &updatedModbusDeviceModel)).To(gomega.BeNil())
 		})
-		framework.ConformanceIt("E2E_UPDATE_DEVICE_MODEL_4: Update device model for incorrect device model", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "led")
+		framework.ConformanceIt("E2E_UPDATE_DEVICE_MODEL_2: Update device model for incorrect device model", func() {
+			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceModel(edgeClientSet, http.MethodPatch, utils.UpdatedLedDeviceModel().Name, "incorrect-model")
+			err = utils.HandleDeviceModel(edgeClientSet, http.MethodPatch, utils.UpdatedModbusDeviceModel().Name, utils.IncorrectModel)
 			gomega.Expect(err).NotTo(gomega.BeNil())
 		})
 		framework.ConformanceIt("E2E_DELETE_DEVICE_MODEL_1: Delete non existent device model(No Protocol)", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodDelete, utils.NewLedDeviceModel().Name, "")
+			err := utils.HandleDeviceModel(edgeClientSet, http.MethodDelete, utils.NewModbusDeviceModel().Name, "")
 			gomega.Expect(err).To(gomega.BeNil())
 		})
 	})
@@ -196,86 +146,10 @@ var _ = GroupDescribe("Device Management test in E2E scenario", func() {
 			}
 			utils.PrintTestcaseNameandStatus()
 		})
-		ginkgo.It("E2E_CREATE_DEVICE_1: Create device instance for LED device (No Protocol)", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "led")
+		ginkgo.It("E2E_CREATE_DEVICE_1: Create device instance for modbus protocol", func() {
+			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			newLedDevice := utils.NewLedDeviceInstance(constants.NodeName)
-
-			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.CheckDeviceExists(deviceInstanceList, &newLedDevice)
-			gomega.Expect(err).To(gomega.BeNil())
-
-			time.Sleep(10 * time.Second)
-
-			configMap, err := clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(err).To(gomega.BeNil())
-
-			isEqual := utils.CompareConfigMaps(*configMap, utils.NewConfigMapLED(constants.NodeName))
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-			go utils.TwinSubscribe(utils.NewLedDeviceInstance(constants.NodeName).Name)
-			gomega.Eventually(func() bool {
-				return utils.TwinResult.Twin != nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device information not reaching edge!!")
-			stringValue := "ON"
-			expectedTwin := map[string]*utils.MsgTwin{
-				"power-status": {
-					Expected: &utils.TwinValue{
-						Value: &stringValue,
-					},
-					Metadata: &utils.TypeMetadata{
-						Type: "string",
-					},
-				},
-			}
-			isEqual = utils.CompareTwin(utils.TwinResult.Twin, expectedTwin)
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-		})
-		ginkgo.It("E2E_CREATE_DEVICE_2: Create device instance for bluetooth protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "bluetooth")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "bluetooth")
-			gomega.Expect(err).To(gomega.BeNil())
-			newBluetoothDevice := utils.NewBluetoothDeviceInstance(constants.NodeName)
-
-			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.CheckDeviceExists(deviceInstanceList, &newBluetoothDevice)
-			gomega.Expect(err).To(gomega.BeNil())
-
-			time.Sleep(3 * time.Second)
-
-			configMap, err := clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(err).To(gomega.BeNil())
-
-			isEqual := utils.CompareConfigMaps(*configMap, utils.NewConfigMapBluetooth(constants.NodeName))
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-			go utils.TwinSubscribe(utils.NewBluetoothDeviceInstance(constants.NodeName).Name)
-			gomega.Eventually(func() bool {
-				return utils.TwinResult.Twin != nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device information not reaching edge!!")
-			ioData := "1"
-			expectedTwin := map[string]*utils.MsgTwin{
-				"io-data": {
-					Expected: &utils.TwinValue{
-						Value: &ioData,
-					},
-					Metadata: &utils.TypeMetadata{
-						Type: "int",
-					},
-				},
-			}
-			isEqual = utils.CompareTwin(utils.TwinResult.Twin, expectedTwin)
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-		})
-		ginkgo.It("E2E_CREATE_DEVICE_3: Create device instance for modbus protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "modbus")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "modbus")
+			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
 			newModbusDevice := utils.NewModbusDeviceInstance(constants.NodeName)
 
@@ -284,168 +158,11 @@ var _ = GroupDescribe("Device Management test in E2E scenario", func() {
 
 			err = utils.CheckDeviceExists(deviceInstanceList, &newModbusDevice)
 			gomega.Expect(err).To(gomega.BeNil())
-
-			time.Sleep(3 * time.Second)
-
-			configMap, err := clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(err).To(gomega.BeNil())
-
-			isEqual := utils.CompareConfigMaps(*configMap, utils.NewConfigMapModbus(constants.NodeName))
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-			go utils.TwinSubscribe(utils.NewModbusDeviceInstance(constants.NodeName).Name)
-			gomega.Eventually(func() bool {
-				return utils.TwinResult.Twin != nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device information not reaching edge!!")
-			stringValue := off
-			expectedTwin := map[string]*utils.MsgTwin{
-				"temperature-enable": {
-					Expected: &utils.TwinValue{
-						Value: &stringValue,
-					},
-					Metadata: &utils.TypeMetadata{
-						Type: "string",
-					},
-				},
-			}
-			isEqual = utils.CompareTwin(utils.TwinResult.Twin, expectedTwin)
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-		})
-		ginkgo.It("E2E_CREATE_DEVICE_4: Create device instance for customized protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "customized")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "customized")
-			gomega.Expect(err).To(gomega.BeNil())
-			newCustomizedDevice := utils.NewCustomizedDeviceInstance(constants.NodeName)
-
-			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.CheckDeviceExists(deviceInstanceList, &newCustomizedDevice)
-			gomega.Expect(err).To(gomega.BeNil())
-
-			time.Sleep(3 * time.Second)
-
-			configMap, err := clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(err).To(gomega.BeNil())
-
-			isEqual := utils.CompareConfigMaps(*configMap, utils.NewConfigMapCustomized(constants.NodeName))
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-			go utils.TwinSubscribe(utils.NewCustomizedDeviceInstance(constants.NodeName).Name)
-			gomega.Eventually(func() bool {
-				return utils.TwinResult.Twin != nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device information not reaching edge!!")
-			stringValue := "OFF"
-			expectedTwin := map[string]*utils.MsgTwin{
-				"temperature-enable": {
-					Expected: &utils.TwinValue{
-						Value: &stringValue,
-					},
-					Metadata: &utils.TypeMetadata{
-						Type: "string",
-					},
-				},
-			}
-			isEqual = utils.CompareTwin(utils.TwinResult.Twin, expectedTwin)
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-		})
-		ginkgo.It("E2E_UPDATE_DEVICE_1: Update device instance for LED device (No Protocol)", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			newLedDevice := utils.NewLedDeviceInstance(constants.NodeName)
-			time.Sleep(2 * time.Second)
-			gomega.Eventually(func() bool {
-				deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-				if err != nil {
-					return false
-				}
-
-				err = utils.CheckDeviceExists(deviceInstanceList, &newLedDevice)
-				return err == nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device creation is not finished!!")
-
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPatch, constants.NodeName, utils.UpdatedLedDeviceInstance(constants.NodeName).Name, "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			updatedLedDevice := utils.UpdatedLedDeviceInstance(constants.NodeName)
-			time.Sleep(2 * time.Second)
-
-			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.CheckDeviceExists(deviceInstanceList, &updatedLedDevice)
-			gomega.Expect(err).To(gomega.BeNil())
-
-			go utils.TwinSubscribe(utils.UpdatedLedDeviceInstance(constants.NodeName).Name)
-			gomega.Eventually(func() bool {
-				return utils.TwinResult.Twin != nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device information not reaching edge!!")
-			stringValue := off
-			expectedTwin := map[string]*utils.MsgTwin{
-				"power-status": {
-					Expected: &utils.TwinValue{
-						Value: &stringValue,
-					},
-					Metadata: &utils.TypeMetadata{
-						Type: "string",
-					},
-				},
-			}
-			isEqual := utils.CompareTwin(utils.TwinResult.Twin, expectedTwin)
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-		})
-		ginkgo.It("E2E_UPDATE_DEVICE_2: Update device instance for bluetooth protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "bluetooth")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "bluetooth")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			newBluetoothDevice := utils.NewBluetoothDeviceInstance(constants.NodeName)
-			time.Sleep(2 * time.Second)
-			gomega.Eventually(func() bool {
-				deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-				if err != nil {
-					return false
-				}
-
-				err = utils.CheckDeviceExists(deviceInstanceList, &newBluetoothDevice)
-				return err == nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device creation is not finished!!")
-
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPatch, constants.NodeName, utils.UpdatedBluetoothDeviceInstance(constants.NodeName).Name, "bluetooth")
-			gomega.Expect(err).To(gomega.BeNil())
-			updatedBluetoothDevice := utils.UpdatedBluetoothDeviceInstance(constants.NodeName)
-			time.Sleep(2 * time.Second)
-
-			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.CheckDeviceExists(deviceInstanceList, &updatedBluetoothDevice)
-			gomega.Expect(err).To(gomega.BeNil())
-
-			go utils.TwinSubscribe(utils.UpdatedBluetoothDeviceInstance(constants.NodeName).Name)
-			gomega.Eventually(func() bool {
-				return utils.TwinResult.Twin != nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device information not reaching edge!!")
-			ioData := "1"
-			expectedTwin := map[string]*utils.MsgTwin{
-				"io-data": {
-					Expected: &utils.TwinValue{
-						Value: &ioData,
-					},
-					Metadata: &utils.TypeMetadata{
-						Type: "int",
-					},
-				},
-			}
-			isEqual := utils.CompareTwin(utils.TwinResult.Twin, expectedTwin)
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
 		})
-		ginkgo.It("E2E_UPDATE_DEVICE_3: Update device instance for modbus protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "modbus")
+		ginkgo.It("E2E_UPDATE_DEVICE_1: Update device instance for modbus protocol", func() {
+			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "modbus")
+			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
 
 			newModbusDevice := utils.NewModbusDeviceInstance(constants.NodeName)
@@ -460,7 +177,7 @@ var _ = GroupDescribe("Device Management test in E2E scenario", func() {
 				return err == nil
 			}, "20s", "2s").Should(gomega.Equal(true), "Device creation is not finished!!")
 
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPatch, constants.NodeName, utils.UpdatedModbusDeviceInstance(constants.NodeName).Name, "modbus")
+			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPatch, constants.NodeName, utils.UpdatedModbusDeviceInstance(constants.NodeName).Name, utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
 			updatedModbusDevice := utils.UpdatedModbusDeviceInstance(constants.NodeName)
 			time.Sleep(2 * time.Second)
@@ -470,181 +187,36 @@ var _ = GroupDescribe("Device Management test in E2E scenario", func() {
 
 			err = utils.CheckDeviceExists(deviceInstanceList, &updatedModbusDevice)
 			gomega.Expect(err).To(gomega.BeNil())
-
-			go utils.TwinSubscribe(utils.UpdatedModbusDeviceInstance(constants.NodeName).Name)
-			gomega.Eventually(func() bool {
-				return utils.TwinResult.Twin != nil
-			}, "20s", "2s").Should(gomega.Equal(true), "Device information not reaching edge!!")
-			stringValue := "ON"
-			expectedTwin := map[string]*utils.MsgTwin{
-				"temperature-enable": {
-					Expected: &utils.TwinValue{
-						Value: &stringValue,
-					},
-					Metadata: &utils.TypeMetadata{
-						Type: "string",
-					},
-				},
-			}
-			isEqual := utils.CompareTwin(utils.TwinResult.Twin, expectedTwin)
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
 		})
-		ginkgo.It("E2E_UPDATE_DEVICE_4: Update device instance for incorrect device instance", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "led")
+		ginkgo.It("E2E_UPDATE_DEVICE_2: Update device instance for incorrect device instance", func() {
+			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "led")
+			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPatch, constants.NodeName, utils.UpdatedLedDeviceInstance(constants.NodeName).Name, "incorrect-instance")
+			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPatch, constants.NodeName, utils.UpdatedModbusDeviceInstance(constants.NodeName).Name, utils.IncorrectInstance)
 			gomega.Expect(err).NotTo(gomega.BeNil())
 		})
-		ginkgo.It("E2E_UPDATE_DEVICE_4: Update device instance data and twin for modbus protocol", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "modbus")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "modbus")
-			gomega.Expect(err).To(gomega.BeNil())
-			newModbusDevice := utils.NewModbusDeviceInstance(constants.NodeName)
-
-			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.CheckDeviceExists(deviceInstanceList, &newModbusDevice)
+		ginkgo.It("E2E_DELETE_DEVICE_1: Delete device instance for an existing device", func() {
+			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
-
-			time.Sleep(3 * time.Second)
-
-			configMap, err := clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(err).To(gomega.BeNil())
-
-			isEqual := utils.CompareConfigMaps(*configMap, utils.NewConfigMapModbus(constants.NodeName))
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-			// update twins and data section should reflect on change on config map
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPatch, constants.NodeName, utils.UpdatedModbusDeviceInstance(constants.NodeName).Name, "modbus")
-			gomega.Expect(err).To(gomega.BeNil())
-			updatedModbusDevice := utils.UpdatedModbusDeviceInstance(constants.NodeName)
-			time.Sleep(3 * time.Second)
-
-			deviceInstanceList, err = utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.CheckDeviceExists(deviceInstanceList, &updatedModbusDevice)
-			gomega.Expect(err).To(gomega.BeNil())
-
-			updatedConfigMap, err := clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(err).To(gomega.BeNil())
-
-			updatedConfigMap.TypeMeta = metav1.TypeMeta{
-				Kind:       "ConfigMap",
-				APIVersion: "v1",
-			}
-
-			isEqual = utils.CompareDeviceProfileInConfigMaps(*updatedConfigMap, utils.UpdatedConfigMapModbusForDataAndTwins(constants.NodeName))
-			gomega.Expect(isEqual).Should(gomega.Equal(true))
-		})
-		ginkgo.It("E2E_DELETE_DEVICE_1: Delete device instance for an existing device (No Protocol)", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "led")
+			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", utils.ModBus)
 			gomega.Expect(err).To(gomega.BeNil())
 			time.Sleep(1 * time.Second)
 
-			_, err = clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodDelete, constants.NodeName, utils.NewLedDeviceInstance(constants.NodeName).Name, "")
-			gomega.Expect(err).To(gomega.BeNil())
-			time.Sleep(1 * time.Second)
-
-			_, err = clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(apierrors.IsNotFound(err)).To(gomega.BeTrue())
-		})
-		ginkgo.It("E2E_DELETE_DEVICE_2: Delete device instance for a non-existing device", func() {
-			err := utils.HandleDeviceInstance(edgeClientSet, http.MethodDelete, constants.NodeName, utils.NewLedDeviceModel().Name, "")
-			gomega.Expect(err).To(gomega.BeNil())
-		})
-		ginkgo.It("E2E_DELETE_DEVICE_3: Delete device instance without device model", func() {
-			err := utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			time.Sleep(1 * time.Second)
-
-			_, err = clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(err).To(gomega.BeNil())
-
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodDelete, constants.NodeName, utils.NewLedDeviceInstance(constants.NodeName).Name, "")
+			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodDelete, constants.NodeName, utils.NewModbusDeviceInstance(constants.NodeName).Name, "")
 			gomega.Expect(err).To(gomega.BeNil())
 			time.Sleep(1 * time.Second)
 
-			_, err = clientSet.CoreV1().ConfigMaps("default").Get(context.TODO(), "device-profile-config-"+constants.NodeName, metav1.GetOptions{})
-			gomega.Expect(apierrors.IsNotFound(err)).To(gomega.BeTrue())
-		})
-	})
-	ginkgo.Context("Test Change in device twin", func() {
-		ginkgo.BeforeEach(func() {
-			// Delete the device instances created
-			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-			for _, device := range deviceInstanceList {
-				err := utils.HandleDeviceInstance(edgeClientSet, http.MethodDelete, constants.NodeName, device.Name, "")
-				gomega.Expect(err).To(gomega.BeNil())
-			}
-			// Delete any pre-existing device models
-			list, err := utils.ListDeviceModel(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-			for _, model := range list {
-				err := utils.HandleDeviceModel(edgeClientSet, http.MethodDelete, model.Name, "")
-				gomega.Expect(err).To(gomega.BeNil())
-			}
-			utils.TwinResult = utils.DeviceTwinResult{}
-			// Get current test SpecReport
-			testSpecReport = ginkgo.CurrentGinkgoTestDescription()
-			// Start test timer
-			testTimer = utils.CRDTestTimerGroup.NewTestTimer(testSpecReport.TestText)
-		})
-		ginkgo.AfterEach(func() {
-			// End test timer
-			testTimer.End()
-			// Print result
-			testTimer.PrintResult()
-			// Delete the device instances created
-			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-			for _, device := range deviceInstanceList {
-				err := utils.HandleDeviceInstance(edgeClientSet, http.MethodDelete, constants.NodeName, device.Name, "")
-				gomega.Expect(err).To(gomega.BeNil())
-			}
-			// Delete the device models created
-			list, err := utils.ListDeviceModel(edgeClientSet, "default")
-			gomega.Expect(err).To(gomega.BeNil())
-			for _, model := range list {
-				err := utils.HandleDeviceModel(edgeClientSet, http.MethodDelete, model.Name, "")
-				gomega.Expect(err).To(gomega.BeNil())
-			}
-			utils.PrintTestcaseNameandStatus()
-		})
-		ginkgo.It("E2E_TWIN_STATE_1: Change the twin state of an existing device", func() {
-			err := utils.HandleDeviceModel(edgeClientSet, http.MethodPost, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			err = utils.HandleDeviceInstance(edgeClientSet, http.MethodPost, constants.NodeName, "", "led")
-			gomega.Expect(err).To(gomega.BeNil())
-			newLedDevice := utils.NewLedDeviceInstance(constants.NodeName)
-			time.Sleep(3 * time.Second)
-			var deviceTwinUpdateMessage utils.DeviceTwinUpdate
-			reportedValue := off
-			deviceTwinUpdateMessage.Twin = map[string]*utils.MsgTwin{
-				"power-status": {Actual: &utils.TwinValue{Value: &reportedValue}, Metadata: &utils.TypeMetadata{Type: "string"}},
-			}
-			err = utils.ChangeTwinValue(deviceTwinUpdateMessage, utils.NewLedDeviceInstance(constants.NodeName).Name)
-			gomega.Expect(err).To(gomega.BeNil())
-			time.Sleep(3 * time.Second)
-			newLedDevice = utils.NewLedDeviceInstance(constants.NodeName)
-
+			newModbusDevice := utils.NewModbusDeviceInstance(constants.NodeName)
 			deviceInstanceList, err := utils.ListDevice(edgeClientSet, "default")
 			gomega.Expect(err).To(gomega.BeNil())
 
-			err = utils.CheckDeviceExists(deviceInstanceList, &newLedDevice)
+			err = utils.CheckDeviceExists(deviceInstanceList, &newModbusDevice)
+			gomega.Expect(err).NotTo(gomega.BeNil())
+		})
+		ginkgo.It("E2E_DELETE_DEVICE_2: Delete device instance for a non-existing device", func() {
+			err := utils.HandleDeviceInstance(edgeClientSet, http.MethodDelete, constants.NodeName, utils.NewModbusDeviceModel().Name, "")
 			gomega.Expect(err).To(gomega.BeNil())
-
-			gomega.Expect(deviceInstanceList[0].Status.Twins[0].PropertyName).To(gomega.Equal("power-status"))
-			gomega.Expect(deviceInstanceList[0].Status.Twins[0].Reported.Value).To(gomega.Equal(off))
 		})
 	})
 })
diff --git a/tests/e2e/utils/common.go b/tests/e2e/utils/common.go
index a795f79ca..f4f9f6f13 100644
--- a/tests/e2e/utils/common.go
+++ b/tests/e2e/utils/common.go
@@ -38,7 +38,7 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/klog/v2"
 
-	"github.com/kubeedge/kubeedge/pkg/apis/devices/v1alpha2"
+	"github.com/kubeedge/kubeedge/pkg/apis/devices/v1beta1"
 	edgeclientset "github.com/kubeedge/kubeedge/pkg/client/clientset/versioned"
 	"github.com/kubeedge/kubeedge/tests/e2e/constants"
 )
@@ -50,11 +50,9 @@ const (
 	TwinETGetSuffix       = "/twin/get"
 	TwinETGetResultSuffix = "/twin/get/result"
 
-	BlueTooth         = "bluetooth"
 	ModBus            = "modbus"
-	Led               = "led"
 	IncorrectInstance = "incorrect-instance"
-	Customized        = "customized"
+	IncorrectModel    = "incorrect-model"
 )
 
 var TokenClient Token
@@ -214,7 +212,7 @@ func HandleDeviceModel(c edgeclientset.Interface, operation string, UID string,
 	switch operation {
 	case http.MethodPost:
 		body := newDeviceModelObject(protocolType, false)
-		_, err := c.DevicesV1alpha2().DeviceModels("default").Create(context.TODO(), body, metav1.CreateOptions{})
+		_, err := c.DevicesV1beta1().DeviceModels("default").Create(context.TODO(), body, metav1.CreateOptions{})
 		return err
 
 	case http.MethodPatch:
@@ -224,11 +222,11 @@ func HandleDeviceModel(c edgeclientset.Interface, operation string, UID string,
 			Fatalf("Marshalling body failed: %v", err)
 		}
 
-		_, err = c.DevicesV1alpha2().DeviceModels("default").Patch(context.TODO(), UID, types.MergePatchType, reqBytes, metav1.PatchOptions{})
+		_, err = c.DevicesV1beta1().DeviceModels("default").Patch(context.TODO(), UID, types.MergePatchType, reqBytes, metav1.PatchOptions{})
 		return err
 
 	case http.MethodDelete:
-		err := c.DevicesV1alpha2().DeviceModels("default").Delete(context.TODO(), UID, metav1.DeleteOptions{})
+		err := c.DevicesV1beta1().DeviceModels("default").Delete(context.TODO(), UID, metav1.DeleteOptions{})
 		if err != nil && apierrors.IsNotFound(err) {
 			return nil
 		}
@@ -239,25 +237,25 @@ func HandleDeviceModel(c edgeclientset.Interface, operation string, UID string,
 }
 
 // HandleDeviceInstance to handle app deployment/delete using pod spec.
-func HandleDeviceInstance(c edgeclientset.Interface, operation string, nodeSelector string, UID string, protocolType string) error {
+func HandleDeviceInstance(c edgeclientset.Interface, operation string, nodeName string, UID string, protocolType string) error {
 	switch operation {
 	case http.MethodPost:
-		body := newDeviceInstanceObject(nodeSelector, protocolType, false)
-		_, err := c.DevicesV1alpha2().Devices("default").Create(context.TODO(), body, metav1.CreateOptions{})
+		body := newDeviceInstanceObject(nodeName, protocolType, false)
+		_, err := c.DevicesV1beta1().Devices("default").Create(context.TODO(), body, metav1.CreateOptions{})
 		return err
 
 	case http.MethodPatch:
-		body := newDeviceInstanceObject(nodeSelector, protocolType, true)
+		body := newDeviceInstanceObject(nodeName, protocolType, true)
 		reqBytes, err := json.Marshal(body)
 		if err != nil {
 			Fatalf("Marshalling body failed: %v", err)
 		}
 
-		_, err = c.DevicesV1alpha2().Devices("default").Patch(context.TODO(), UID, types.MergePatchType, reqBytes, metav1.PatchOptions{})
+		_, err = c.DevicesV1beta1().Devices("default").Patch(context.TODO(), UID, types.MergePatchType, reqBytes, metav1.PatchOptions{})
 		return err
 
 	case http.MethodDelete:
-		err := c.DevicesV1alpha2().Devices("default").Delete(context.TODO(), UID, metav1.DeleteOptions{})
+		err := c.DevicesV1beta1().Devices("default").Delete(context.TODO(), UID, metav1.DeleteOptions{})
 		if err != nil && apierrors.IsNotFound(err) {
 			return nil
 		}
@@ -268,29 +266,19 @@ func HandleDeviceInstance(c edgeclientset.Interface, operation string, nodeSelec
 }
 
 // newDeviceInstanceObject creates a new device instance object
-func newDeviceInstanceObject(nodeSelector string, protocolType string, updated bool) *v1alpha2.Device {
-	var deviceInstance v1alpha2.Device
+func newDeviceInstanceObject(nodeName string, protocolType string, updated bool) *v1beta1.Device {
+	var deviceInstance v1beta1.Device
 	if !updated {
 		switch protocolType {
-		case BlueTooth:
-			deviceInstance = NewBluetoothDeviceInstance(nodeSelector)
 		case ModBus:
-			deviceInstance = NewModbusDeviceInstance(nodeSelector)
-		case Led:
-			deviceInstance = NewLedDeviceInstance(nodeSelector)
-		case Customized:
-			deviceInstance = NewCustomizedDeviceInstance(nodeSelector)
+			deviceInstance = NewModbusDeviceInstance(nodeName)
 		case IncorrectInstance:
 			deviceInstance = IncorrectDeviceInstance()
 		}
 	} else {
 		switch protocolType {
-		case BlueTooth:
-			deviceInstance = UpdatedBluetoothDeviceInstance(nodeSelector)
 		case ModBus:
-			deviceInstance = UpdatedModbusDeviceInstance(nodeSelector)
-		case Led:
-			deviceInstance = UpdatedLedDeviceInstance(nodeSelector)
+			deviceInstance = UpdatedModbusDeviceInstance(nodeName)
 		case IncorrectInstance:
 			deviceInstance = IncorrectDeviceInstance()
 		}
@@ -299,46 +287,36 @@ func newDeviceInstanceObject(nodeSelector string, protocolType string, updated b
 }
 
 // newDeviceModelObject creates a new device model object
-func newDeviceModelObject(protocolType string, updated bool) *v1alpha2.DeviceModel {
-	var deviceModel v1alpha2.DeviceModel
+func newDeviceModelObject(protocolType string, updated bool) *v1beta1.DeviceModel {
+	var deviceModel v1beta1.DeviceModel
 	if !updated {
 		switch protocolType {
-		case BlueTooth:
-			deviceModel = NewBluetoothDeviceModel()
 		case ModBus:
 			deviceModel = NewModbusDeviceModel()
-		case Led:
-			deviceModel = NewLedDeviceModel()
-		case Customized:
-			deviceModel = NewCustomizedDeviceModel()
-		case "incorrect-model":
+		case IncorrectModel:
 			deviceModel = IncorrectDeviceModel()
 		}
 	} else {
 		switch protocolType {
-		case BlueTooth:
-			deviceModel = UpdatedBluetoothDeviceModel()
 		case ModBus:
 			deviceModel = UpdatedModbusDeviceModel()
-		case Led:
-			deviceModel = UpdatedLedDeviceModel()
-		case "incorrect-model":
+		case IncorrectModel:
 			deviceModel = IncorrectDeviceModel()
 		}
 	}
 	return &deviceModel
 }
 
-func ListDeviceModel(c edgeclientset.Interface, ns string) ([]v1alpha2.DeviceModel, error) {
-	deviceModelList, err := c.DevicesV1alpha2().DeviceModels(ns).List(context.TODO(), metav1.ListOptions{})
+func ListDeviceModel(c edgeclientset.Interface, ns string) ([]v1beta1.DeviceModel, error) {
+	deviceModelList, err := c.DevicesV1beta1().DeviceModels(ns).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
 		return nil, err
 	}
 	return deviceModelList.Items, nil
 }
 
-func ListDevice(c edgeclientset.Interface, ns string) ([]v1alpha2.Device, error) {
-	deviceList, err := c.DevicesV1alpha2().Devices(ns).List(context.TODO(), metav1.ListOptions{})
+func ListDevice(c edgeclientset.Interface, ns string) ([]v1beta1.Device, error) {
+	deviceList, err := c.DevicesV1beta1().Devices(ns).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -346,7 +324,7 @@ func ListDevice(c edgeclientset.Interface, ns string) ([]v1alpha2.Device, error)
 }
 
 // CheckDeviceModelExists verify whether the contents of the device model matches with what is expected
-func CheckDeviceModelExists(deviceModels []v1alpha2.DeviceModel, expectedDeviceModel *v1alpha2.DeviceModel) error {
+func CheckDeviceModelExists(deviceModels []v1beta1.DeviceModel, expectedDeviceModel *v1beta1.DeviceModel) error {
 	modelExists := false
 	for _, deviceModel := range deviceModels {
 		if expectedDeviceModel.ObjectMeta.Name == deviceModel.ObjectMeta.Name {
@@ -366,7 +344,7 @@ func CheckDeviceModelExists(deviceModels []v1alpha2.DeviceModel, expectedDeviceM
 	return nil
 }
 
-func CheckDeviceExists(deviceList []v1alpha2.Device, expectedDevice *v1alpha2.Device) error {
+func CheckDeviceExists(deviceList []v1beta1.Device, expectedDevice *v1beta1.Device) error {
 	deviceExists := false
 	for _, device := range deviceList {
 		if expectedDevice.ObjectMeta.Name == device.ObjectMeta.Name {
@@ -377,21 +355,6 @@ func CheckDeviceExists(deviceList []v1alpha2.Device, expectedDevice *v1alpha2.De
 				!reflect.DeepEqual(expectedDevice.Spec, device.Spec) {
 				return fmt.Errorf("the device is not matching with what was expected")
 			}
-			twinExists := false
-			for _, expectedTwin := range expectedDevice.Status.Twins {
-				for _, twin := range device.Status.Twins {
-					if expectedTwin.PropertyName == twin.PropertyName {
-						twinExists = true
-						if !reflect.DeepEqual(expectedTwin.Desired, twin.Desired) {
-							return fmt.Errorf("Status twin " + twin.PropertyName + " not as expected")
-						}
-						break
-					}
-				}
-			}
-			if !twinExists {
-				return fmt.Errorf("status twin(s) not found")
-			}
 			break
 		}
 	}
@@ -484,27 +447,6 @@ func OnTwinMessageReceived(client MQTT.Client, message MQTT.Message) {
 	}
 }
 
-// CompareConfigMaps is used to compare 2 config maps
-func CompareConfigMaps(configMap, expectedConfigMap v1.ConfigMap) bool {
-	Infof("expectedConfigMap.Data: %v", expectedConfigMap.Data)
-	Infof("configMap.Data %v", configMap.Data)
-
-	if expectedConfigMap.ObjectMeta.Namespace != configMap.ObjectMeta.Namespace || !reflect.DeepEqual(expectedConfigMap.Data, configMap.Data) {
-		return false
-	}
-	return true
-}
-
-// CompareDeviceProfileInConfigMaps is used to compare 2 device profile in config maps
-func CompareDeviceProfileInConfigMaps(configMap, expectedConfigMap v1.ConfigMap) bool {
-	deviceProfile := configMap.Data["deviceProfile.json"]
-	ExpectedDeviceProfile := expectedConfigMap.Data["deviceProfile.json"]
-	var deviceProfileMap, expectedDeviceProfileMap map[string]interface{}
-	_ = json.Unmarshal([]byte(deviceProfile), &deviceProfileMap)
-	_ = json.Unmarshal([]byte(ExpectedDeviceProfile), &expectedDeviceProfileMap)
-	return reflect.DeepEqual(expectedConfigMap.TypeMeta, configMap.TypeMeta)
-}
-
 // CompareTwin is used to compare 2 device Twins
 func CompareTwin(deviceTwin map[string]*MsgTwin, expectedDeviceTwin map[string]*MsgTwin) bool {
 	for key := range expectedDeviceTwin {
diff --git a/tests/e2e/utils/device.go b/tests/e2e/utils/device.go
index 22cc15ed2..7dd379745 100644
--- a/tests/e2e/utils/device.go
+++ b/tests/e2e/utils/device.go
@@ -1,464 +1,91 @@
 package utils
 
 import (
-	"encoding/json"
-
 	v12 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/utils/pointer"
 
-	"github.com/kubeedge/kubeedge/cloud/pkg/devicecontroller/types"
-	"github.com/kubeedge/kubeedge/pkg/apis/devices/v1alpha2"
+	"github.com/kubeedge/kubeedge/pkg/apis/devices/v1beta1"
 )
 
-func NewLedDeviceModel() v1alpha2.DeviceModel {
-	deviceProperty1 := v1alpha2.DeviceProperty{
-		Name:        "power-status",
-		Description: "Indicates whether the led light is ON/OFF",
-		Type: v1alpha2.PropertyType{String: &v1alpha2.PropertyTypeString{
-			AccessMode:   "ReadWrite",
-			DefaultValue: "OFF",
-		}},
-	}
-	deviceProperty2 := v1alpha2.DeviceProperty{
-		Name:        "gpio-pin-number",
-		Description: "Indicates the GPIO pin to which LED is connected",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadOnly",
-			DefaultValue: 18,
-		}},
-	}
-	properties := []v1alpha2.DeviceProperty{deviceProperty1, deviceProperty2}
-	newDeviceModel := v1alpha2.DeviceModel{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "DeviceModel",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "led-light",
-			Namespace: Namespace,
-		},
-		Spec: v1alpha2.DeviceModelSpec{
-			Properties: properties,
-		},
-	}
-	return newDeviceModel
-}
-
-func NewModbusDeviceModel() v1alpha2.DeviceModel {
-	deviceProperty1 := v1alpha2.DeviceProperty{
+func NewModbusDeviceModel() v1beta1.DeviceModel {
+	modelProperty1 := v1beta1.ModelProperty{
 		Name:        "temperature",
 		Description: "temperature in degree celsius",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode: "ReadWrite",
-			Maximum:    100,
-			Unit:       "degree celsius",
-		}},
+		Type:        v1beta1.INT,
+		AccessMode:  "ReadWrite",
+		Maximum:     "100",
+		Unit:        "degree celsius",
 	}
-	deviceProperty2 := v1alpha2.DeviceProperty{
-		Name:        "temperature-enable",
-		Description: "enable data collection of temperature sensor",
-		Type: v1alpha2.PropertyType{String: &v1alpha2.PropertyTypeString{
-			AccessMode:   "ReadWrite",
-			DefaultValue: "OFF",
-		}},
-	}
-	properties := []v1alpha2.DeviceProperty{deviceProperty1, deviceProperty2}
 
-	newDeviceModel := v1alpha2.DeviceModel{
+	newDeviceModel := v1beta1.DeviceModel{
 		TypeMeta: v1.TypeMeta{
 			Kind:       "DeviceModel",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
+			APIVersion: "devices.kubeedge.io/v1beta1",
 		},
 		ObjectMeta: v1.ObjectMeta{
 			Name:      "sensor-tag-model",
 			Namespace: Namespace,
 		},
-		Spec: v1alpha2.DeviceModelSpec{
-			Properties: properties,
+		Spec: v1beta1.DeviceModelSpec{
+			Properties: []v1beta1.ModelProperty{modelProperty1},
 		},
 	}
 	return newDeviceModel
 }
 
-func NewBluetoothDeviceModel() v1alpha2.DeviceModel {
-	deviceProperty1 := v1alpha2.DeviceProperty{
+func UpdatedModbusDeviceModel() v1beta1.DeviceModel {
+	modelProperty1 := v1beta1.ModelProperty{
 		Name:        "temperature",
 		Description: "temperature in degree celsius",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode: "ReadOnly",
-			Maximum:    100,
-			Unit:       "degree celsius",
-		}},
-	}
-	deviceProperty2 := v1alpha2.DeviceProperty{
-		Name:        "temperature-enable",
-		Description: "enable data collection of temperature sensor",
-		Type: v1alpha2.PropertyType{String: &v1alpha2.PropertyTypeString{
-			AccessMode:   "ReadWrite",
-			DefaultValue: "ON",
-		}},
-	}
-	deviceProperty3 := v1alpha2.DeviceProperty{
-		Name:        "io-config-initialize",
-		Description: "initialize io-config with value 0",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 0,
-		}},
-	}
-	deviceProperty4 := v1alpha2.DeviceProperty{
-		Name:        "io-data-initialize",
-		Description: "initialize io-data with value 0",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 0,
-		}},
+		Type:        v1beta1.INT,
+		AccessMode:  "ReadWrite",
+		Maximum:     "200",
+		Unit:        "degree celsius",
 	}
-	deviceProperty5 := v1alpha2.DeviceProperty{
-		Name:        "io-config",
-		Description: "register activation of io-config",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 1,
-		}},
-	}
-	deviceProperty6 := v1alpha2.DeviceProperty{
-		Name:        "io-data",
-		Description: "data field to control io-control",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 0,
-		}},
-	}
-	properties := []v1alpha2.DeviceProperty{deviceProperty1, deviceProperty2, deviceProperty3, deviceProperty4, deviceProperty5, deviceProperty6}
-	newDeviceModel := v1alpha2.DeviceModel{
+	newDeviceModel := v1beta1.DeviceModel{
 		TypeMeta: v1.TypeMeta{
 			Kind:       "DeviceModel",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "cc2650-sensortag",
-			Namespace: Namespace,
-		},
-		Spec: v1alpha2.DeviceModelSpec{
-			Properties: properties,
-		},
-	}
-	return newDeviceModel
-}
-
-func NewCustomizedDeviceModel() v1alpha2.DeviceModel {
-	deviceProperty1 := v1alpha2.DeviceProperty{
-		Name:        "temperature",
-		Description: "temperature in degree celsius",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode: "ReadWrite",
-			Maximum:    100,
-			Unit:       "degree celsius",
-		}},
-	}
-	deviceProperty2 := v1alpha2.DeviceProperty{
-		Name:        "temperature-enable",
-		Description: "enable data collection of temperature sensor",
-		Type: v1alpha2.PropertyType{String: &v1alpha2.PropertyTypeString{
-			AccessMode:   "ReadWrite",
-			DefaultValue: "OFF",
-		}},
-	}
-	properties := []v1alpha2.DeviceProperty{deviceProperty1, deviceProperty2}
-	newDeviceModel := v1alpha2.DeviceModel{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "DeviceModel",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "sensor-tag-customized-model",
-			Namespace: Namespace,
-		},
-		Spec: v1alpha2.DeviceModelSpec{
-			Properties: properties,
-		},
-	}
-	return newDeviceModel
-}
-
-func UpdatedLedDeviceModel() v1alpha2.DeviceModel {
-	deviceProperty1 := v1alpha2.DeviceProperty{
-		Name:        "power-status",
-		Description: "Indicates whether the led light is ON/OFF",
-		Type: v1alpha2.PropertyType{String: &v1alpha2.PropertyTypeString{
-			AccessMode:   "ReadWrite",
-			DefaultValue: "ON",
-		}},
-	}
-	deviceProperty2 := v1alpha2.DeviceProperty{
-		Name:        "gpio-pin-number",
-		Description: "Indicates the GPIO pin to which LED is connected",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 17,
-		}},
-	}
-	properties := []v1alpha2.DeviceProperty{deviceProperty1, deviceProperty2}
-	updatedDeviceModel := v1alpha2.DeviceModel{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "DeviceModel",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "led-light",
-			Namespace: Namespace,
-		},
-		Spec: v1alpha2.DeviceModelSpec{
-			Properties: properties,
-		},
-	}
-	return updatedDeviceModel
-}
-
-func UpdatedModbusDeviceModel() v1alpha2.DeviceModel {
-	deviceProperty1 := v1alpha2.DeviceProperty{
-		Name:        "temperature",
-		Description: "temperature in degree",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode: "ReadOnly",
-			Maximum:    200,
-			Unit:       "celsius",
-		}},
-	}
-	deviceProperty2 := v1alpha2.DeviceProperty{
-		Name:        "temperature-enable",
-		Description: "enable data collection of temperature sensor",
-		Type: v1alpha2.PropertyType{String: &v1alpha2.PropertyTypeString{
-			AccessMode:   "ReadWrite",
-			DefaultValue: "ON",
-		}},
-	}
-	properties := []v1alpha2.DeviceProperty{deviceProperty1, deviceProperty2}
-	newDeviceModel := v1alpha2.DeviceModel{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "DeviceModel",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
+			APIVersion: "devices.kubeedge.io/v1beta1",
 		},
 		ObjectMeta: v1.ObjectMeta{
 			Name:      "sensor-tag-model",
 			Namespace: Namespace,
 		},
-		Spec: v1alpha2.DeviceModelSpec{
-			Properties: properties,
+		Spec: v1beta1.DeviceModelSpec{
+			Properties: []v1beta1.ModelProperty{modelProperty1},
 		},
 	}
 	return newDeviceModel
 }
 
-func UpdatedBluetoothDeviceModel() v1alpha2.DeviceModel {
-	deviceProperty1 := v1alpha2.DeviceProperty{
-		Name:        "temperature",
-		Description: "temperature in degree",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode: "ReadOnly",
-			Maximum:    200,
-			Unit:       "degree",
-		}},
-	}
-	deviceProperty2 := v1alpha2.DeviceProperty{
-		Name:        "temperature-enable",
-		Description: "enable data collection of temperature sensor",
-		Type: v1alpha2.PropertyType{String: &v1alpha2.PropertyTypeString{
-			AccessMode:   "ReadWrite",
-			DefaultValue: "OFF",
-		}},
-	}
-	deviceProperty3 := v1alpha2.DeviceProperty{
-		Name:        "io-config-initialize",
-		Description: "initialize io-config with value 0",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 0,
-		}},
-	}
-	deviceProperty4 := v1alpha2.DeviceProperty{
-		Name:        "io-data-initialize",
-		Description: "initialize io-data with value 0",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 0,
-		}},
-	}
-	deviceProperty5 := v1alpha2.DeviceProperty{
-		Name:        "io-config",
-		Description: "register activation of io-config",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 1,
-		}},
-	}
-	deviceProperty6 := v1alpha2.DeviceProperty{
-		Name:        "io-data",
-		Description: "data field to control io-control",
-		Type: v1alpha2.PropertyType{Int: &v1alpha2.PropertyTypeInt64{
-			AccessMode:   "ReadWrite",
-			DefaultValue: 0,
-		}},
-	}
-	properties := []v1alpha2.DeviceProperty{deviceProperty1, deviceProperty2, deviceProperty3, deviceProperty4, deviceProperty5, deviceProperty6}
-	newDeviceModel := v1alpha2.DeviceModel{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "DeviceModel",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "cc2650-sensortag",
-			Namespace: Namespace,
-		},
-		Spec: v1alpha2.DeviceModelSpec{
-			Properties: properties,
-		},
-	}
-	return newDeviceModel
-}
-
-func NewLedDeviceInstance(nodeSelector string) v1alpha2.Device {
-	deviceInstance := v1alpha2.Device{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "Device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "led-light-instance-01",
-			Namespace: Namespace,
-			Labels: map[string]string{
-				"description": "LEDLight",
-				"model":       "led-light",
-			},
-		},
-		Spec: v1alpha2.DeviceSpec{
-			DeviceModelRef: &v12.LocalObjectReference{
-				Name: "led-light",
-			},
-			NodeSelector: &v12.NodeSelector{
-				NodeSelectorTerms: []v12.NodeSelectorTerm{
-					{
-						MatchExpressions: []v12.NodeSelectorRequirement{
-							{
-								Key:      "",
-								Operator: v12.NodeSelectorOpIn,
-								Values:   []string{nodeSelector},
-							},
-						},
-					},
-				},
-			},
-		},
-		Status: v1alpha2.DeviceStatus{
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "power-status",
-					Desired: v1alpha2.TwinProperty{
-						Value: "ON",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-		},
-	}
-
-	return deviceInstance
-}
-
-// NewMockInstance create an instance for mock bluetooth device.
-func NewMockInstance(nodeSelector string) v1alpha2.Device {
-	deviceInstance := v1alpha2.Device{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "Device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "mock-temp-sensor-instance",
-			Namespace: Namespace,
-			Labels: map[string]string{
-				"description":  "TemperatureSensor",
-				"manufacturer": "TemperatureInstruments",
-				"model":        "sensortagmock",
-			},
-		},
-		Spec: v1alpha2.DeviceSpec{
-			DeviceModelRef: &v12.LocalObjectReference{
-				Name: "mock-temp-sensor-model",
-			},
-			NodeSelector: &v12.NodeSelector{
-				NodeSelectorTerms: []v12.NodeSelectorTerm{
-					{
-						MatchExpressions: []v12.NodeSelectorRequirement{
-							{
-								Key:      "",
-								Operator: v12.NodeSelectorOpIn,
-								Values:   []string{nodeSelector},
-							},
-						},
-					},
-				},
-			},
+func NewModbusDeviceInstance(nodeName string) v1beta1.Device {
+	property := v1beta1.DeviceProperty{
+		Name: "temperature",
+		Desired: v1beta1.TwinProperty{
+			Value: "20",
 		},
-		Status: v1alpha2.DeviceStatus{
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "io-data",
-					Desired: v1alpha2.TwinProperty{
-						Value: "Red",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
+		CollectCycle:  1000,
+		ReportCycle:   1000,
+		ReportToCloud: true,
+		Visitors: v1beta1.VisitorConfig{
+			ProtocolName: "modbus",
+			ConfigData: &v1beta1.CustomizedValue{
+				Data: map[string]interface{}{
+					"Register":       "CoilRegister",
+					"Offset":         "2",
+					"Limit":          "1",
+					"Scale":          "1",
+					"IsSwap":         "true",
+					"IsRegisterSwap": "true",
 				},
 			},
 		},
 	}
-	return deviceInstance
-}
 
-func NewModbusDeviceInstance(nodeSelector string) v1alpha2.Device {
-	devicePropertyVisitor1 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Modbus: &v1alpha2.VisitorConfigModbus{
-				Register:       "CoilRegister",
-				Offset:         pointer.Int64Ptr(2),
-				Limit:          pointer.Int64Ptr(1),
-				Scale:          1,
-				IsSwap:         true,
-				IsRegisterSwap: true,
-			},
-		},
-	}
-	devicePropertyVisitor2 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature-enable",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Modbus: &v1alpha2.VisitorConfigModbus{
-				Register:       "DiscreteInputRegister",
-				Offset:         pointer.Int64Ptr(3),
-				Limit:          pointer.Int64Ptr(1),
-				Scale:          1.0,
-				IsSwap:         true,
-				IsRegisterSwap: true,
-			},
-		},
-	}
-	propertyVisitors := []v1alpha2.DevicePropertyVisitor{devicePropertyVisitor1, devicePropertyVisitor2}
-
-	deviceInstance := v1alpha2.Device{
+	deviceInstance := v1beta1.Device{
 		TypeMeta: v1.TypeMeta{
 			Kind:       "Device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
+			APIVersion: "devices.kubeedge.io/v1beta1",
 		},
 		ObjectMeta: v1.ObjectMeta{
 			Name:      "sensor-tag-instance-02",
@@ -469,385 +96,45 @@ func NewModbusDeviceInstance(nodeSelector string) v1alpha2.Device {
 				"model":        "CC2650",
 			},
 		},
-		Spec: v1alpha2.DeviceSpec{
+		Spec: v1beta1.DeviceSpec{
 			DeviceModelRef: &v12.LocalObjectReference{
 				Name: "sensor-tag-model",
 			},
-			NodeSelector: &v12.NodeSelector{
-				NodeSelectorTerms: []v12.NodeSelectorTerm{
-					{
-						MatchExpressions: []v12.NodeSelectorRequirement{
-							{
-								Key:      "",
-								Operator: v12.NodeSelectorOpIn,
-								Values:   []string{nodeSelector},
-							},
-						},
-					},
-				},
-			},
-			PropertyVisitors: propertyVisitors,
-		},
-		Status: v1alpha2.DeviceStatus{
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "temperature-enable",
-					Desired: v1alpha2.TwinProperty{
-						Value: "OFF",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
+			NodeName:   nodeName,
+			Properties: []v1beta1.DeviceProperty{property},
 		},
 	}
 	return deviceInstance
 }
 
-func NewBluetoothDeviceInstance(nodeSelector string) v1alpha2.Device {
-	devicePropertyVisitor1 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa0104514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 2,
-					EndIndex:   1,
-					ShiftRight: 2,
-					OrderOfOperations: []v1alpha2.BluetoothOperations{
-						{
-							BluetoothOperationType:  "Multiply",
-							BluetoothOperationValue: 0.03125,
-						},
-					},
-				},
-			},
-		},
-	}
-	devicePropertyVisitor2 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature-enable",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa0204514000b000000000000000",
-				DataWriteToBluetooth: map[string][]byte{
-					"ON":  {1},
-					"OFF": {0},
-				},
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
+func UpdatedModbusDeviceInstance(nodeName string) v1beta1.Device {
+	property := v1beta1.DeviceProperty{
+		Name: "temperature",
+		Desired: v1beta1.TwinProperty{
+			Value: "20",
 		},
-	}
-	devicePropertyVisitor3 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "io-config-initialize",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6604514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	devicePropertyVisitor4 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "io-data-initialize",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6504514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	devicePropertyVisitor5 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "io-config",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6604514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
+		CollectCycle:  1000,
+		ReportCycle:   1000,
+		ReportToCloud: true,
+		Visitors: v1beta1.VisitorConfig{
+			ProtocolName: "modbus",
+			ConfigData: &v1beta1.CustomizedValue{
+				Data: map[string]interface{}{
+					"Register":       "CoilRegister",
+					"Offset":         "2",
+					"Limit":          "1",
+					"Scale":          "1",
+					"IsSwap":         "true",
+					"IsRegisterSwap": "true",
 				},
 			},
 		},
 	}
-	devicePropertyVisitor6 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "io-data",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6504514000b000000000000000",
-				DataWriteToBluetooth: map[string][]byte{
-					"Red":            {1},
-					"Green":          {2},
-					"RedGreen":       {3},
-					"Buzzer":         {4},
-					"BuzzerRed":      {5},
-					"BuzzerGreen":    {6},
-					"BuzzerRedGreen": {7},
-				},
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	propertyVisitors := []v1alpha2.DevicePropertyVisitor{devicePropertyVisitor1, devicePropertyVisitor2, devicePropertyVisitor3, devicePropertyVisitor4, devicePropertyVisitor5, devicePropertyVisitor6}
-
-	deviceInstance := v1alpha2.Device{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "Device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "sensor-tag-instance-01",
-			Namespace: Namespace,
-			Labels: map[string]string{
-				"description":  "TISimplelinkSensorTag",
-				"manufacturer": "TexasInstruments",
-				"model":        "cc2650-sensortag",
-			},
-		},
-		Spec: v1alpha2.DeviceSpec{
-			DeviceModelRef: &v12.LocalObjectReference{
-				Name: "cc2650-sensortag",
-			},
-			NodeSelector: &v12.NodeSelector{
-				NodeSelectorTerms: []v12.NodeSelectorTerm{
-					{
-						MatchExpressions: []v12.NodeSelectorRequirement{
-							{
-								Key:      "",
-								Operator: v12.NodeSelectorOpIn,
-								Values:   []string{nodeSelector},
-							},
-						},
-					},
-				},
-			},
-			Protocol: v1alpha2.ProtocolConfig{
-				Bluetooth: &v1alpha2.ProtocolConfigBluetooth{
-					MACAddress: "BC:6A:29:AE:CC:96",
-				},
-			},
-			PropertyVisitors: propertyVisitors,
-		},
-		Status: v1alpha2.DeviceStatus{
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "io-data",
-					Desired: v1alpha2.TwinProperty{
-						Value: "1",
-						Metadata: map[string]string{
-							"type": "int",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-		},
-	}
-	return deviceInstance
-}
 
-func NewCustomizedDeviceInstance(nodeSelector string) v1alpha2.Device {
-	devicePropertyVisitor1 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			CustomizedProtocol: &v1alpha2.VisitorConfigCustomized{
-				ProtocolName: "CustomizedProtocol1",
-				ConfigData: &v1alpha2.CustomizedValue{
-					Data: map[string]interface{}{
-						"config1": "config-val1",
-						"config2": "config-val2",
-					},
-				},
-			},
-		},
-	}
-	devicePropertyVisitor2 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature-enable",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			CustomizedProtocol: &v1alpha2.VisitorConfigCustomized{
-				ProtocolName: "CustomizedProtocol1",
-				ConfigData: &v1alpha2.CustomizedValue{
-					Data: map[string]interface{}{
-						"config3": "config-val3",
-						"config4": "config-val4",
-					},
-				},
-			},
-		},
-	}
-	propertyVisitors := []v1alpha2.DevicePropertyVisitor{devicePropertyVisitor1, devicePropertyVisitor2}
-	deviceInstance := v1alpha2.Device{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "Device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "sensor-tag-customized-instance-01",
-			Namespace: Namespace,
-			Labels: map[string]string{
-				"description":  "TISimplelinkSensorTag",
-				"manufacturer": "TexasInstruments",
-				"model":        "CC2650",
-			},
-		},
-		Spec: v1alpha2.DeviceSpec{
-			DeviceModelRef: &v12.LocalObjectReference{
-				Name: "sensor-tag-customized-model",
-			},
-			NodeSelector: &v12.NodeSelector{
-				NodeSelectorTerms: []v12.NodeSelectorTerm{
-					{
-						MatchExpressions: []v12.NodeSelectorRequirement{
-							{
-								Key:      "",
-								Operator: v12.NodeSelectorOpIn,
-								Values:   []string{nodeSelector},
-							},
-						},
-					},
-				},
-			},
-			Protocol: v1alpha2.ProtocolConfig{
-				CustomizedProtocol: &v1alpha2.ProtocolConfigCustomized{
-					ProtocolName: "CustomizedProtocol1",
-					ConfigData: &v1alpha2.CustomizedValue{
-						Data: map[string]interface{}{
-							"config1": "config-val1",
-							"config2": "config-val2",
-						},
-					},
-				},
-				Common: &v1alpha2.ProtocolConfigCommon{
-					COM: &v1alpha2.ProtocolConfigCOM{
-						SerialPort: "/dev/ttyS0",
-						BaudRate:   9600,
-						DataBits:   8,
-						Parity:     "even",
-						StopBits:   1,
-					},
-				},
-			},
-			PropertyVisitors: propertyVisitors,
-		},
-		Status: v1alpha2.DeviceStatus{
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "temperature-enable",
-					Desired: v1alpha2.TwinProperty{
-						Value: "OFF",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-		},
-	}
-	return deviceInstance
-}
-
-func UpdatedLedDeviceInstance(nodeSelector string) v1alpha2.Device {
-	deviceInstance := v1alpha2.Device{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "Device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "led-light-instance-01",
-			Namespace: Namespace,
-			Labels: map[string]string{
-				"description": "LEDLight-1",
-				"model":       "led-light-1",
-			},
-		},
-		Spec: v1alpha2.DeviceSpec{
-			DeviceModelRef: &v12.LocalObjectReference{
-				Name: "led-light",
-			},
-			NodeSelector: &v12.NodeSelector{
-				NodeSelectorTerms: []v12.NodeSelectorTerm{
-					{
-						MatchExpressions: []v12.NodeSelectorRequirement{
-							{
-								Key:      "",
-								Operator: v12.NodeSelectorOpIn,
-								Values:   []string{nodeSelector},
-							},
-						},
-					},
-				},
-			},
-		},
-		Status: v1alpha2.DeviceStatus{
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "power-status",
-					Desired: v1alpha2.TwinProperty{
-						Value: "OFF",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-		},
-	}
-	return deviceInstance
-}
-
-func UpdatedModbusDeviceInstance(nodeSelector string) v1alpha2.Device {
-	devicePropertyVisitor1 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Modbus: &v1alpha2.VisitorConfigModbus{
-				Register:       "CoilRegister",
-				Offset:         pointer.Int64Ptr(2),
-				Limit:          pointer.Int64Ptr(1),
-				Scale:          2,
-				IsSwap:         true,
-				IsRegisterSwap: true,
-			},
-		},
-	}
-	devicePropertyVisitor2 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature-enable",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Modbus: &v1alpha2.VisitorConfigModbus{
-				Register:       "DiscreteInputRegister",
-				Offset:         pointer.Int64Ptr(1),
-				Limit:          pointer.Int64Ptr(1),
-				Scale:          1.0,
-				IsSwap:         true,
-				IsRegisterSwap: true,
-			},
-		},
-	}
-	propertyVisitors := []v1alpha2.DevicePropertyVisitor{devicePropertyVisitor1, devicePropertyVisitor2}
-	deviceInstance := v1alpha2.Device{
+	deviceInstance := v1beta1.Device{
 		TypeMeta: v1.TypeMeta{
 			Kind:       "Device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
+			APIVersion: "devices.kubeedge.io/v1beta1",
 		},
 		ObjectMeta: v1.ObjectMeta{
 			Name:      "sensor-tag-instance-02",
@@ -858,227 +145,32 @@ func UpdatedModbusDeviceInstance(nodeSelector string) v1alpha2.Device {
 				"model":        "CC2650-sensorTag",
 			},
 		},
-		Spec: v1alpha2.DeviceSpec{
+		Spec: v1beta1.DeviceSpec{
 			DeviceModelRef: &v12.LocalObjectReference{
 				Name: "sensor-tag-model",
 			},
-			NodeSelector: &v12.NodeSelector{
-				NodeSelectorTerms: []v12.NodeSelectorTerm{
-					{
-						MatchExpressions: []v12.NodeSelectorRequirement{
-							{
-								Key:      "",
-								Operator: v12.NodeSelectorOpIn,
-								Values:   []string{nodeSelector},
-							},
-						},
-					},
-				},
-			},
-			Protocol: v1alpha2.ProtocolConfig{
-				Modbus: &v1alpha2.ProtocolConfigModbus{
-					SlaveID: pointer.Int64Ptr(1),
-				},
-				Common: &v1alpha2.ProtocolConfigCommon{
-					COM: &v1alpha2.ProtocolConfigCOM{
-						SerialPort: "/dev/ttyS0",
-						BaudRate:   9600,
-						DataBits:   8,
-						Parity:     "even",
-						StopBits:   1,
-					},
-				},
-			},
-			PropertyVisitors: propertyVisitors,
-			Data: v1alpha2.DeviceData{
-				DataProperties: []v1alpha2.DataProperty{
-					{
-						PropertyName: "temperature",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-				},
-				DataTopic: "$ke/events/+/device/customized/update",
-			},
-		},
-		Status: v1alpha2.DeviceStatus{
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "temperature-enable",
-					Desired: v1alpha2.TwinProperty{
-						Value: "ON",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
+			NodeName:   nodeName,
+			Properties: []v1beta1.DeviceProperty{property},
+			Protocol: v1beta1.ProtocolConfig{
+				ProtocolName: "modbus",
+				ConfigData: &v1beta1.CustomizedValue{Data: map[string]interface{}{
+					"SerialPort": "/dev/ttyS0",
+					"BaudRate":   "9600",
+					"DataBits":   "8",
+					"Parity":     "even",
+					"StopBits":   "1",
+				}},
 			},
 		},
 	}
 	return deviceInstance
 }
 
-func UpdatedBluetoothDeviceInstance(nodeSelector string) v1alpha2.Device {
-	devicePropertyVisitor1 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa0104514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   3,
-					ShiftRight: 1,
-					OrderOfOperations: []v1alpha2.BluetoothOperations{
-						{
-							BluetoothOperationType:  "Multiply",
-							BluetoothOperationValue: 0.05,
-						},
-					},
-				},
-			},
-		},
-	}
-	devicePropertyVisitor2 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "temperature-enable",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa0204514000b000000000000000",
-				DataWriteToBluetooth: map[string][]byte{
-					"ON":  {1},
-					"OFF": {0},
-				},
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	devicePropertyVisitor3 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "io-config-initialize",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6604514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	devicePropertyVisitor4 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "io-data-initialize",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6504514000b000000000000001",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	devicePropertyVisitor5 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "io-config",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6604514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	devicePropertyVisitor6 := v1alpha2.DevicePropertyVisitor{
-		PropertyName: "io-data",
-		VisitorConfig: v1alpha2.VisitorConfig{
-			Bluetooth: &v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6504514000b000000000000000",
-				DataWriteToBluetooth: map[string][]byte{
-					"Red":            {2},
-					"Green":          {3},
-					"RedGreen":       {4},
-					"Buzzer":         {5},
-					"BuzzerRed":      {6},
-					"BuzzerGreen":    {7},
-					"BuzzerRedGreen": {8},
-				},
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	propertyVisitors := []v1alpha2.DevicePropertyVisitor{devicePropertyVisitor1, devicePropertyVisitor2, devicePropertyVisitor3, devicePropertyVisitor4, devicePropertyVisitor5, devicePropertyVisitor6}
-	deviceInstance := v1alpha2.Device{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "Device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "sensor-tag-instance-01",
-			Namespace: Namespace,
-			Labels: map[string]string{
-				"description":  "TISensorTag",
-				"manufacturer": "TexasInstruments-TI",
-				"model":        "cc2650-sensor-tag",
-			},
-		},
-		Spec: v1alpha2.DeviceSpec{
-			DeviceModelRef: &v12.LocalObjectReference{
-				Name: "cc2650-sensortag",
-			},
-			NodeSelector: &v12.NodeSelector{
-				NodeSelectorTerms: []v12.NodeSelectorTerm{
-					{
-						MatchExpressions: []v12.NodeSelectorRequirement{
-							{
-								Key:      "",
-								Operator: v12.NodeSelectorOpIn,
-								Values:   []string{nodeSelector},
-							},
-						},
-					},
-				},
-			},
-			Protocol: v1alpha2.ProtocolConfig{
-				Bluetooth: &v1alpha2.ProtocolConfigBluetooth{
-					MACAddress: "BC:6A:29:AE:CC:69",
-				},
-			},
-			PropertyVisitors: propertyVisitors,
-		},
-		Status: v1alpha2.DeviceStatus{
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "io-data",
-					Desired: v1alpha2.TwinProperty{
-						Value: "1",
-						Metadata: map[string]string{
-							"type": "int",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-		},
-	}
-	return deviceInstance
-}
-
-func IncorrectDeviceModel() v1alpha2.DeviceModel {
-	newDeviceModel := v1alpha2.DeviceModel{
+func IncorrectDeviceModel() v1beta1.DeviceModel {
+	newDeviceModel := v1beta1.DeviceModel{
 		TypeMeta: v1.TypeMeta{
 			Kind:       "device-model",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
+			APIVersion: "devices.kubeedge.io/v1beta1",
 		},
 		ObjectMeta: v1.ObjectMeta{
 			Name:      "led-light",
@@ -1088,11 +180,11 @@ func IncorrectDeviceModel() v1alpha2.DeviceModel {
 	return newDeviceModel
 }
 
-func IncorrectDeviceInstance() v1alpha2.Device {
-	deviceInstance := v1alpha2.Device{
+func IncorrectDeviceInstance() v1beta1.Device {
+	deviceInstance := v1beta1.Device{
 		TypeMeta: v1.TypeMeta{
 			Kind:       "device",
-			APIVersion: "devices.kubeedge.io/v1alpha2",
+			APIVersion: "devices.kubeedge.io/v1beta1",
 		},
 		ObjectMeta: v1.ObjectMeta{
 			Name:      "led-light-instance-01",
@@ -1105,658 +197,3 @@ func IncorrectDeviceInstance() v1alpha2.Device {
 	}
 	return deviceInstance
 }
-
-func NewConfigMapLED(nodeSelector string) v12.ConfigMap {
-	configMap := v12.ConfigMap{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "ConfigMap",
-			APIVersion: "v1",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "device-profile-config-" + nodeSelector,
-			Namespace: Namespace,
-		},
-	}
-	configMap.Data = make(map[string]string)
-
-	deviceProfile := &types.DeviceProfile{}
-	deviceProfile.DeviceInstances = []*types.DeviceInstance{
-		{
-			Name:  "led-light-instance-01",
-			ID:    "led-light-instance-01",
-			Model: "led-light",
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "power-status",
-					Desired: v1alpha2.TwinProperty{
-						Value: "ON",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-		},
-	}
-	deviceProfile.DeviceModels = []*types.DeviceModel{
-		{
-			Name: "led-light",
-			Properties: []*types.Property{
-				{
-					Name:         "power-status",
-					DataType:     "string",
-					Description:  "Indicates whether the led light is ON/OFF",
-					AccessMode:   "ReadWrite",
-					DefaultValue: "OFF",
-				},
-				{
-					Name:         "gpio-pin-number",
-					DataType:     "int",
-					Description:  "Indicates the GPIO pin to which LED is connected",
-					AccessMode:   "ReadOnly",
-					DefaultValue: 18,
-					Maximum:      0,
-					Minimum:      0,
-				},
-			},
-		},
-	}
-	deviceProfile.Protocols = []*types.Protocol{
-		{
-			ProtocolConfig: nil,
-		},
-	}
-
-	bytes, err := json.Marshal(deviceProfile)
-	if err != nil {
-		Errorf("Failed to marshal deviceprofile: %v", deviceProfile)
-	}
-	configMap.Data["deviceProfile.json"] = string(bytes)
-
-	return configMap
-}
-
-func NewConfigMapBluetooth(nodeSelector string) v12.ConfigMap {
-	configMap := v12.ConfigMap{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "ConfigMap",
-			APIVersion: "v1",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "device-profile-config-" + nodeSelector,
-			Namespace: Namespace,
-		},
-	}
-	configMap.Data = make(map[string]string)
-
-	propertyVisitors := []*types.PropertyVisitor{
-		{
-			Name:         "temperature",
-			PropertyName: "temperature",
-			ModelName:    "cc2650-sensortag",
-			Protocol:     "bluetooth",
-			VisitorConfig: v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa0104514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					OrderOfOperations: []v1alpha2.BluetoothOperations{
-						{
-							BluetoothOperationType:  "Multiply",
-							BluetoothOperationValue: 0.03125,
-						},
-					},
-					ShiftRight: 2,
-					StartIndex: 2,
-					EndIndex:   1,
-				},
-			},
-		},
-		{
-			Name:         "temperature-enable",
-			PropertyName: "temperature-enable",
-			ModelName:    "cc2650-sensortag",
-			Protocol:     "bluetooth",
-			VisitorConfig: v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa0204514000b000000000000000",
-				DataWriteToBluetooth: map[string][]byte{
-					"ON":  {1},
-					"OFF": {0},
-				},
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-		{
-			Name:         "io-config-initialize",
-			PropertyName: "io-config-initialize",
-			ModelName:    "cc2650-sensortag",
-			Protocol:     "bluetooth",
-			VisitorConfig: v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6604514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-		{
-			Name:         "io-data-initialize",
-			PropertyName: "io-data-initialize",
-			ModelName:    "cc2650-sensortag",
-			Protocol:     "bluetooth",
-			VisitorConfig: v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6504514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-		{
-			Name:         "io-config",
-			PropertyName: "io-config",
-			ModelName:    "cc2650-sensortag",
-			Protocol:     "bluetooth",
-			VisitorConfig: v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6604514000b000000000000000",
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-		{
-			Name:         "io-data",
-			PropertyName: "io-data",
-			ModelName:    "cc2650-sensortag",
-			Protocol:     "bluetooth",
-			VisitorConfig: v1alpha2.VisitorConfigBluetooth{
-				CharacteristicUUID: "f000aa6504514000b000000000000000",
-				DataWriteToBluetooth: map[string][]byte{
-					"Red":            {1},
-					"Green":          {2},
-					"RedGreen":       {3},
-					"Buzzer":         {4},
-					"BuzzerRed":      {5},
-					"BuzzerGreen":    {6},
-					"BuzzerRedGreen": {7},
-				},
-				BluetoothDataConverter: v1alpha2.BluetoothReadConverter{
-					StartIndex: 1,
-					EndIndex:   1,
-				},
-			},
-		},
-	}
-	deviceProfile := &types.DeviceProfile{}
-	deviceProfile.DeviceInstances = []*types.DeviceInstance{
-		{
-			Name:     "sensor-tag-instance-01",
-			ID:       "sensor-tag-instance-01",
-			Protocol: "bluetooth-sensor-tag-instance-01",
-			Model:    "cc2650-sensortag",
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "io-data",
-					Desired: v1alpha2.TwinProperty{
-						Value: "1",
-						Metadata: map[string]string{
-							"type": "int",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-			PropertyVisitors: propertyVisitors,
-		},
-	}
-	deviceProfile.DeviceModels = []*types.DeviceModel{
-		{
-			Name: "cc2650-sensortag",
-			Properties: []*types.Property{
-				{
-					Name:         "temperature",
-					DataType:     "int",
-					Description:  "temperature in degree celsius",
-					AccessMode:   "ReadOnly",
-					DefaultValue: 0,
-					Maximum:      100,
-					Minimum:      0,
-					Unit:         "degree celsius",
-				},
-				{
-					Name:         "temperature-enable",
-					DataType:     "string",
-					Description:  "enable data collection of temperature sensor",
-					AccessMode:   "ReadWrite",
-					DefaultValue: "ON",
-				},
-				{
-					Name:         "io-config-initialize",
-					DataType:     "int",
-					Description:  "initialize io-config with value 0",
-					AccessMode:   "ReadWrite",
-					DefaultValue: 0,
-					Maximum:      0,
-					Minimum:      0,
-				},
-				{
-					Name:         "io-data-initialize",
-					DataType:     "int",
-					Description:  "initialize io-data with value 0",
-					AccessMode:   "ReadWrite",
-					DefaultValue: 0,
-					Maximum:      0,
-					Minimum:      0,
-				},
-				{
-					Name:         "io-config",
-					DataType:     "int",
-					Description:  "register activation of io-config",
-					AccessMode:   "ReadWrite",
-					DefaultValue: 1,
-					Maximum:      0,
-					Minimum:      0,
-				}, {
-					Name:         "io-data",
-					DataType:     "int",
-					Description:  "data field to control io-control",
-					AccessMode:   "ReadWrite",
-					DefaultValue: 0,
-					Maximum:      0,
-					Minimum:      0,
-				},
-			},
-		},
-	}
-	deviceProfile.Protocols = []*types.Protocol{
-		{
-			Name:     "bluetooth-sensor-tag-instance-01",
-			Protocol: "bluetooth",
-			ProtocolConfig: v1alpha2.ProtocolConfigBluetooth{
-				MACAddress: "BC:6A:29:AE:CC:96",
-			},
-		},
-	}
-
-	bytes, err := json.Marshal(deviceProfile)
-	if err != nil {
-		Errorf("Failed to marshal deviceprofile: %v", deviceProfile)
-	}
-	configMap.Data["deviceProfile.json"] = string(bytes)
-
-	return configMap
-}
-
-func NewConfigMapModbus(nodeSelector string) v12.ConfigMap {
-	configMap := v12.ConfigMap{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "ConfigMap",
-			APIVersion: "v1",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "device-profile-config-" + nodeSelector,
-			Namespace: Namespace,
-		},
-	}
-	configMap.Data = make(map[string]string)
-
-	propertyVisitors := []*types.PropertyVisitor{
-		{
-			Name:         "temperature",
-			PropertyName: "temperature",
-			ModelName:    "sensor-tag-model",
-			Protocol:     "modbus",
-			VisitorConfig: v1alpha2.VisitorConfigModbus{
-				Register:       "CoilRegister",
-				Offset:         pointer.Int64Ptr(2),
-				Limit:          pointer.Int64Ptr(1),
-				Scale:          1,
-				IsSwap:         true,
-				IsRegisterSwap: true,
-			},
-		},
-		{
-			Name:         "temperature-enable",
-			PropertyName: "temperature-enable",
-			ModelName:    "sensor-tag-model",
-			Protocol:     "modbus",
-			VisitorConfig: v1alpha2.VisitorConfigModbus{
-				Register:       "DiscreteInputRegister",
-				Offset:         pointer.Int64Ptr(3),
-				Limit:          pointer.Int64Ptr(1),
-				Scale:          1,
-				IsSwap:         true,
-				IsRegisterSwap: true,
-			},
-		},
-	}
-	deviceProfile := &types.DeviceProfile{}
-	deviceProfile.DeviceInstances = []*types.DeviceInstance{
-		{
-			Name:  "sensor-tag-instance-02",
-			ID:    "sensor-tag-instance-02",
-			Model: "sensor-tag-model",
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "temperature-enable",
-					Desired: v1alpha2.TwinProperty{
-						Value: "OFF",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-			PropertyVisitors: propertyVisitors,
-		},
-	}
-	deviceProfile.DeviceModels = []*types.DeviceModel{
-		{
-			Name: "sensor-tag-model",
-			Properties: []*types.Property{
-
-				{
-					Name:         "temperature",
-					DataType:     "int",
-					Description:  "temperature in degree celsius",
-					AccessMode:   "ReadWrite",
-					DefaultValue: 0,
-					Maximum:      100,
-					Minimum:      0,
-					Unit:         "degree celsius",
-				},
-				{
-					Name:         "temperature-enable",
-					DataType:     "string",
-					Description:  "enable data collection of temperature sensor",
-					AccessMode:   "ReadWrite",
-					DefaultValue: "OFF",
-				},
-			},
-		},
-	}
-	deviceProfile.Protocols = []*types.Protocol{
-		{
-			ProtocolConfig: nil,
-		},
-	}
-
-	bytes, err := json.Marshal(deviceProfile)
-	if err != nil {
-		Errorf("Failed to marshal deviceprofile: %v", deviceProfile)
-	}
-	configMap.Data["deviceProfile.json"] = string(bytes)
-
-	return configMap
-}
-
-func UpdatedConfigMapModbusForDataAndTwins(nodeSelector string) v12.ConfigMap {
-	configMap := v12.ConfigMap{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "ConfigMap",
-			APIVersion: "v1",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "device-profile-config-" + nodeSelector,
-			Namespace: Namespace,
-		},
-	}
-	configMap.Data = make(map[string]string)
-
-	propertyVisitors := []*types.PropertyVisitor{
-		{
-			Name:         "temperature",
-			PropertyName: "temperature",
-			ModelName:    "sensor-tag-model",
-			Protocol:     "modbus",
-			VisitorConfig: v1alpha2.VisitorConfigModbus{
-				Register:       "CoilRegister",
-				Offset:         pointer.Int64Ptr(2),
-				Limit:          pointer.Int64Ptr(1),
-				Scale:          1,
-				IsSwap:         true,
-				IsRegisterSwap: true,
-			},
-		},
-		{
-			Name:         "temperature-enable",
-			PropertyName: "temperature-enable",
-			ModelName:    "sensor-tag-model",
-			Protocol:     "modbus",
-			VisitorConfig: v1alpha2.VisitorConfigModbus{
-				Register:       "DiscreteInputRegister",
-				Offset:         pointer.Int64Ptr(3),
-				Limit:          pointer.Int64Ptr(1),
-				Scale:          1,
-				IsSwap:         true,
-				IsRegisterSwap: true,
-			},
-		},
-	}
-
-	deviceProfile := &types.DeviceProfile{}
-	deviceProfile.DeviceInstances = []*types.DeviceInstance{
-		{
-			Name:  "sensor-tag-instance-02",
-			ID:    "sensor-tag-instance-02",
-			Model: "sensor-tag-model",
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "temperature-enable",
-					Desired: v1alpha2.TwinProperty{
-						Value: "ON",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-			Data: &v1alpha2.DeviceData{
-				DataProperties: []v1alpha2.DataProperty{
-					{
-						PropertyName: "temperature",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-				},
-				DataTopic: "$ke/events/+/device/customized/update",
-			},
-			PropertyVisitors: propertyVisitors,
-		},
-	}
-	deviceProfile.DeviceModels = []*types.DeviceModel{
-		{
-			Name: "sensor-tag-model",
-			Properties: []*types.Property{
-
-				{
-					Name:         "temperature",
-					DataType:     "int",
-					Description:  "temperature in degree celsius",
-					AccessMode:   "ReadWrite",
-					DefaultValue: 0,
-					Maximum:      100,
-					Minimum:      0,
-					Unit:         "degree celsius",
-				},
-				{
-					Name:         "temperature-enable",
-					DataType:     "string",
-					Description:  "enable data collection of temperature sensor",
-					AccessMode:   "ReadWrite",
-					DefaultValue: "OFF",
-				},
-			},
-		},
-	}
-	deviceProfile.Protocols = []*types.Protocol{
-		{
-			Name:     "modbus-sensor-tag-instance-02",
-			Protocol: "modbus",
-			ProtocolConfig: &v1alpha2.ProtocolConfigModbus{
-				SlaveID: pointer.Int64Ptr(1),
-			},
-			ProtocolCommonConfig: &v1alpha2.ProtocolConfigCommon{
-				COM: &v1alpha2.ProtocolConfigCOM{
-					SerialPort: "/dev/ttyS0",
-					BaudRate:   9600,
-					DataBits:   8,
-					Parity:     "even",
-					StopBits:   1,
-				},
-			},
-		},
-	}
-
-	bytes, err := json.Marshal(deviceProfile)
-	if err != nil {
-		Errorf("Failed to marshal deviceprofile: %v", deviceProfile)
-	}
-	configMap.Data["deviceProfile.json"] = string(bytes)
-
-	return configMap
-}
-
-func NewConfigMapCustomized(nodeSelector string) v12.ConfigMap {
-	configMap := v12.ConfigMap{
-		TypeMeta: v1.TypeMeta{
-			Kind:       "ConfigMap",
-			APIVersion: "v1",
-		},
-		ObjectMeta: v1.ObjectMeta{
-			Name:      "device-profile-config-" + nodeSelector,
-			Namespace: Namespace,
-		},
-	}
-	configMap.Data = make(map[string]string)
-
-	propertyVisitors := []*types.PropertyVisitor{
-		{
-			Name:         "temperature",
-			PropertyName: "temperature",
-			ModelName:    "sensor-tag-customized-model",
-			Protocol:     "customized-protocol",
-
-			VisitorConfig: v1alpha2.VisitorConfigCustomized{
-				ProtocolName: "CustomizedProtocol1",
-				ConfigData: &v1alpha2.CustomizedValue{
-					Data: map[string]interface{}{
-						"config1": "config-val1",
-						"config2": "config-val2",
-					},
-				},
-			},
-		},
-		{
-			Name:         "temperature-enable",
-			PropertyName: "temperature-enable",
-			ModelName:    "sensor-tag-customized-model",
-			Protocol:     "customized-protocol",
-			VisitorConfig: v1alpha2.VisitorConfigCustomized{
-				ProtocolName: "CustomizedProtocol1",
-				ConfigData: &v1alpha2.CustomizedValue{
-					Data: map[string]interface{}{
-						"config3": "config-val3",
-						"config4": "config-val4",
-					},
-				},
-			},
-		},
-	}
-
-	deviceProfile := &types.DeviceProfile{}
-	deviceProfile.DeviceInstances = []*types.DeviceInstance{
-		{
-			Name:     "sensor-tag-customized-instance-01",
-			ID:       "sensor-tag-customized-instance-01",
-			Model:    "sensor-tag-customized-model",
-			Protocol: "customized-protocol-sensor-tag-customized-instance-01",
-			Twins: []v1alpha2.Twin{
-				{
-					PropertyName: "temperature-enable",
-					Desired: v1alpha2.TwinProperty{
-						Value: "OFF",
-						Metadata: map[string]string{
-							"type": "string",
-						},
-					},
-					Reported: v1alpha2.TwinProperty{
-						Value: "unknown",
-					},
-				},
-			},
-			PropertyVisitors: propertyVisitors,
-		},
-	}
-	deviceProfile.DeviceModels = []*types.DeviceModel{
-		{
-			Name: "sensor-tag-customized-model",
-			Properties: []*types.Property{
-
-				{
-					Name:         "temperature",
-					DataType:     "int",
-					Description:  "temperature in degree celsius",
-					AccessMode:   "ReadWrite",
-					DefaultValue: 0,
-					Maximum:      100,
-					Minimum:      0,
-					Unit:         "degree celsius",
-				},
-				{
-					Name:         "temperature-enable",
-					DataType:     "string",
-					Description:  "enable data collection of temperature sensor",
-					AccessMode:   "ReadWrite",
-					DefaultValue: "OFF",
-				},
-			},
-		},
-	}
-	deviceProfile.Protocols = []*types.Protocol{
-		{
-			Name:     "customized-protocol-sensor-tag-customized-instance-01",
-			Protocol: "customized-protocol",
-			ProtocolConfig: &v1alpha2.ProtocolConfigCustomized{
-				ProtocolName: "CustomizedProtocol1",
-				ConfigData: &v1alpha2.CustomizedValue{
-					Data: map[string]interface{}{
-						"config1": "config-val1",
-						"config2": "config-val2",
-					},
-				},
-			},
-			ProtocolCommonConfig: &v1alpha2.ProtocolConfigCommon{
-				COM: &v1alpha2.ProtocolConfigCOM{
-					SerialPort: "/dev/ttyS0",
-					BaudRate:   9600,
-					DataBits:   8,
-					Parity:     "even",
-					StopBits:   1,
-				},
-			},
-		},
-	}
-
-	bytes, err := json.Marshal(deviceProfile)
-	if err != nil {
-		Errorf("Failed to marshal deviceprofile: %v", deviceProfile)
-	}
-	configMap.Data["deviceProfile.json"] = string(bytes)
-
-	return configMap
-}