github.com/jingruilea/kubeedge@v1.2.0-beta.0.0.20200410162146-4bb8902b3879/cloud/test/integration/crds/validation_test.go

/*
Copyright 2019 The KubeEdge Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package crds

import (
	"encoding/json"
	"os"
	"testing"

	"k8s.io/client-go/rest"
	"k8s.io/client-go/tools/clientcmd"

	"github.com/kubeedge/kubeedge/cloud/pkg/apis/devices/v1alpha1"
	deviceutils "github.com/kubeedge/kubeedge/cloud/pkg/devicecontroller/utils"
	"github.com/kubeedge/kubeedge/cloud/test/integration/fixtures"
)

func buildCrdClient(t *testing.T) *rest.RESTClient {
	kubeConfigPath := os.Getenv("KUBE_CONFIG")
	kubeAPIServerURL := os.Getenv("KUBE_APISERVER_URL")
	kubeConfig, err := clientcmd.BuildConfigFromFlags(kubeAPIServerURL, kubeConfigPath)
	if err != nil {
		t.Fatalf("Failed to build device CRD client, error is %v", err)
		return nil
	}
	crdClient, err := deviceutils.NewCRDClient(kubeConfig)
	if err != nil {
		t.Fatalf("Failed to build device CRD client, error is %v", err)
		return nil
	}
	return crdClient
}

func TestValidDeviceModel(t *testing.T) {
	testNamespace := os.Getenv("TESTNS")
	tests := map[string]struct {
		deviceModelFn func() *v1alpha1.DeviceModel
	}{
		"valid bluetooth device model": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelBluetooth("bluetooth-device-model", testNamespace)
				return deviceModel
			},
		},
		"valid modbus rtu device model": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelModbus("modbus-device-model", testNamespace)
				return deviceModel
			},
		},
		"valid opc ua device model": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelOpcUA("opcua-device-model", testNamespace)
				return deviceModel
			},
		},
	}

	crdClient := buildCrdClient(t)

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			deviceModel := tc.deviceModelFn()
			respBytes, err := json.Marshal(deviceModel)
			if err != nil {
				t.Fatalf("%s : json marshal error : %v", name, err)
			}
			result := crdClient.Post().Name(deviceModel.Name).Namespace(deviceModel.Namespace).Resource(fixtures.ResourceDeviceModel).Body(respBytes).Do()
			if result.Error() != nil {
				t.Fatalf("%s: expected nil err , got %v", name, result.Error())
			}
		})
	}
}

func TestInvalidDeviceModel(t *testing.T) {
	testNamespace := os.Getenv("TESTNS")
	tests := map[string]struct {
		deviceModelFn func() *v1alpha1.DeviceModel
	}{
		"device model with property no name": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.DeviceModelWithPropertyNoName("device-model-property-no-name", testNamespace)
				return deviceModel
			},
		},

		"device model with property bad access mode": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.DeviceModelWithPropertyBadAccessMode("model-property-bad-access-mode", testNamespace)
				return deviceModel
			},
		},

		"device model with ble protocol property bad operation type": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelBluetoothBadOperationType("model-bluetooth-bad-operation-type", testNamespace)
				return deviceModel
			},
		},
		"device model with ble protocol property no start index": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelBluetoothNoStartIndex("model-bluetooth-no-start-index", testNamespace)
				return deviceModel
			},
		},
		"device model with ble protocol property no end index": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelBluetoothNoEndIndex("model-bluetooth-bad-operation-type", testNamespace)
				return deviceModel
			},
		},
		"device model with ble protocol property no characteristic UUID": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelBluetoothNoCharacteristicUUID("model-bluetooth-no-char-uuid", testNamespace)
				return deviceModel
			},
		},
		"device model with modbus protocol property bad register": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelModbusBadRegister("model-modbus-bad-register", testNamespace)
				return deviceModel
			},
		},
		"device model with modbus protocol property no register": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelModbusNoRegister("model-modbus-no-register", testNamespace)
				return deviceModel
			},
		},
		"device model with modbus protocol property no limit": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelModbusNoLimit("model-modbus-no-limit", testNamespace)
				return deviceModel
			},
		},
		"device model with ble protocol with no offset": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelModbusNoOffset("model-modbus-no-offset", testNamespace)
				return deviceModel
			},
		},
		"device model with opc ua property no nodeID": {
			deviceModelFn: func() *v1alpha1.DeviceModel {
				deviceModel := fixtures.NewDeviceModelOpcUANoNodeID("model-modbus-no-nodeID", testNamespace)
				return deviceModel
			},
		},
	}

	crdClient := buildCrdClient(t)

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			deviceModel := tc.deviceModelFn()
			deviceModelJSON, err := json.Marshal(deviceModel)
			if err != nil {
				t.Fatalf("%s : error while marshalling device model : %v", name, err)
			}
			result := crdClient.Post().Name(deviceModel.Name).Namespace(deviceModel.Namespace).Resource(fixtures.ResourceDeviceModel).
				Body(deviceModelJSON).Do()
			if result.Error() == nil {
				t.Fatalf("%s: expected error", name)
			}
		})
	}
}

func TestValidDevice(t *testing.T) {
	testNamespace := os.Getenv("TESTNS")
	tests := map[string]struct {
		deviceInstanceFn func() v1alpha1.Device
	}{
		"valid device with modbus rtu protocol": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTU("device-modbus-rtu", testNamespace)
				return deviceInstance
			},
		},
		"valid device with modbus tcp protocol": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusTCP("device-modbus-tcp", testNamespace)
				return deviceInstance
			},
		},
		"valid device with opc ua protocol": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceOpcUA("device-opcua", testNamespace)
				return deviceInstance
			},
		},
	}

	crdClient := buildCrdClient(t)

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			device := tc.deviceInstanceFn()
			deviceJSON, err := json.Marshal(device)
			if err != nil {
				t.Fatalf("%s : error while marshalling device : %v", name, err)
			}
			result := crdClient.Post().Name(device.Name).Namespace(device.Namespace).Resource(fixtures.ResourceDevice).Body(deviceJSON).Do()
			if result.Error() != nil {
				t.Fatalf("%s expected nil err , got %v", name, result.Error())
			}
		})
	}
}

func TestInvalidDevice(t *testing.T) {
	testNamespace := os.Getenv("TESTNS")
	tests := map[string]struct {
		deviceInstanceFn func() v1alpha1.Device
	}{
		"device modbus rtu no baud rate": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUNoBaudRate("device-modbus-rtu-no-baud-rate", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu bad baud rate": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUBadBaudRate("device-modbus-rtu-bad-baud-rate", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu no data bits": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUNoDataBits("device-modbus-rtu-no-data-bits", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu bad data bits": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUBadDataBits("device-modbus-rtu-bad-data-bits", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu no parity": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUNoParity("device-modbus-rtu-no-parity", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu bad parity": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUBadParity("device-modbus-rtu-bad-parity", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu no serial port": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUNoSerialPort("device-modbus-rtu-no-serial-port", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu no slave id": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUNoSlaveID("device-modbus-rtu-no-slaveID", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu bad slave id": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUBadSlaveID("device-modbus-bad-slaveID", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu no stop bits": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUNoStopBits("device-modbus-rtu-no-stopbits", testNamespace)
				return deviceInstance
			},
		},
		"device modbus rtu bad_stop_bits": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusRTUBadStopBits("device-modbus-rtu-bad-stopbits", testNamespace)
				return deviceInstance
			},
		},
		"device modbus tcp no IP": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusTCPNoIP("device-modbus-tcp-no-IP", testNamespace)
				return deviceInstance
			},
		},
		"device modbus tcp no port": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusTCPNoPort("device-modbus-tcp-no-port", testNamespace)
				return deviceInstance
			},
		},
		"device modbus tcp no slaveID": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceModbusTCPNoSlaveID("device-modbus-tcp-no-slaveID", testNamespace)
				return deviceInstance
			},
		},
		"device opcua no url": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceOpcUANoURL("device-opcua-no-url", testNamespace)
				return deviceInstance
			},
		},
		"device no model reference": {
			deviceInstanceFn: func() v1alpha1.Device {
				deviceInstance := fixtures.NewDeviceNoModelReference("device-no-model-ref", "default")
				return deviceInstance
			},
		},
	}

	crdClient := buildCrdClient(t)

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			device := tc.deviceInstanceFn()
			deviceJSON, err := json.Marshal(device)
			if err != nil {
				t.Fatalf("%s : error while marshalling device : %v", name, err)
			}
			result := crdClient.Post().Name(device.Name).Namespace(device.Namespace).Resource(fixtures.ResourceDevice).Body(deviceJSON).Do()
			if result.Error() == nil {
				t.Fatalf("%s : expected error", name)
			}
		})
	}
}