terraform/builtin/providers/alicloud/validators_test.go

503 lines
16 KiB
Go

package alicloud
import "testing"
func TestValidateInstancePort(t *testing.T) {
validPorts := []int{1, 22, 80, 100, 8088, 65535}
for _, v := range validPorts {
_, errors := validateInstancePort(v, "instance_port")
if len(errors) != 0 {
t.Fatalf("%q should be a valid instance port number between 1 and 65535: %q", v, errors)
}
}
invalidPorts := []int{-10, -1, 0}
for _, v := range invalidPorts {
_, errors := validateInstancePort(v, "instance_port")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid instance port number", v)
}
}
}
func TestValidateInstanceProtocol(t *testing.T) {
validProtocols := []string{"http", "tcp", "https", "udp"}
for _, v := range validProtocols {
_, errors := validateInstanceProtocol(v, "instance_protocol")
if len(errors) != 0 {
t.Fatalf("%q should be a valid instance protocol: %q", v, errors)
}
}
invalidProtocols := []string{"HTTP", "abc", "ecmp", "dubbo"}
for _, v := range invalidProtocols {
_, errors := validateInstanceProtocol(v, "instance_protocol")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid instance protocol", v)
}
}
}
func TestValidateInstanceDiskCategory(t *testing.T) {
validDiskCategory := []string{"cloud", "cloud_efficiency", "cloud_ssd"}
for _, v := range validDiskCategory {
_, errors := validateDiskCategory(v, "instance_disk_category")
if len(errors) != 0 {
t.Fatalf("%q should be a valid instance disk category: %q", v, errors)
}
}
invalidDiskCategory := []string{"all", "ephemeral", "ephemeral_ssd", "ALL", "efficiency"}
for _, v := range invalidDiskCategory {
_, errors := validateDiskCategory(v, "instance_disk_category")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid instance disk category", v)
}
}
}
func TestValidateInstanceName(t *testing.T) {
validInstanceName := []string{"hi", "hi http://", "some word + any word &", "http", "中文"}
for _, v := range validInstanceName {
_, errors := validateInstanceName(v, "instance_name")
if len(errors) != 0 {
t.Fatalf("%q should be a valid instance name: %q", v, errors)
}
}
invalidInstanceName := []string{"y", "http://", "https://", "+"}
for _, v := range invalidInstanceName {
_, errors := validateInstanceName(v, "instance_name")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid instance name", v)
}
}
}
func TestValidateInstanceDescription(t *testing.T) {
validInstanceDescription := []string{"hi", "hi http://", "some word + any word &", "http://", "中文"}
for _, v := range validInstanceDescription {
_, errors := validateInstanceDescription(v, "instance_description")
if len(errors) != 0 {
t.Fatalf("%q should be a valid instance description: %q", v, errors)
}
}
invalidvalidInstanceDescription := []string{"y", ""}
for _, v := range invalidvalidInstanceDescription {
_, errors := validateInstanceName(v, "instance_description")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid instance description", v)
}
}
}
func TestValidateSecurityGroupName(t *testing.T) {
validSecurityGroupName := []string{"hi", "hi http://", "some word + any word &", "http", "中文", "12345"}
for _, v := range validSecurityGroupName {
_, errors := validateSecurityGroupName(v, "security_group_name")
if len(errors) != 0 {
t.Fatalf("%q should be a valid security group name: %q", v, errors)
}
}
invalidSecurityGroupName := []string{"y", "http://", "https://", "+"}
for _, v := range invalidSecurityGroupName {
_, errors := validateSecurityGroupName(v, "security_group_name")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid security group name", v)
}
}
}
func TestValidateSecurityGroupDescription(t *testing.T) {
validSecurityGroupDescription := []string{"hi", "hi http://", "some word + any word &", "http://", "中文"}
for _, v := range validSecurityGroupDescription {
_, errors := validateSecurityGroupDescription(v, "security_group_description")
if len(errors) != 0 {
t.Fatalf("%q should be a valid security group description: %q", v, errors)
}
}
invalidSecurityGroupDescription := []string{"y", ""}
for _, v := range invalidSecurityGroupDescription {
_, errors := validateSecurityGroupDescription(v, "security_group_description")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid security group description", v)
}
}
}
func TestValidateSecurityRuleType(t *testing.T) {
validSecurityRuleType := []string{"ingress", "egress"}
for _, v := range validSecurityRuleType {
_, errors := validateSecurityRuleType(v, "security_rule_type")
if len(errors) != 0 {
t.Fatalf("%q should be a valid security rule type: %q", v, errors)
}
}
invalidSecurityRuleType := []string{"y", "gress", "in", "out"}
for _, v := range invalidSecurityRuleType {
_, errors := validateSecurityRuleType(v, "security_rule_type")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid security rule type", v)
}
}
}
func TestValidateSecurityRuleIpProtocol(t *testing.T) {
validIpProtocol := []string{"tcp", "udp", "icmp", "gre", "all"}
for _, v := range validIpProtocol {
_, errors := validateSecurityRuleIpProtocol(v, "security_rule_ip_protocol")
if len(errors) != 0 {
t.Fatalf("%q should be a valid ip protocol: %q", v, errors)
}
}
invalidIpProtocol := []string{"y", "ecmp", "http", "https"}
for _, v := range invalidIpProtocol {
_, errors := validateSecurityRuleIpProtocol(v, "security_rule_ip_protocol")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid ip protocol", v)
}
}
}
func TestValidateSecurityRuleNicType(t *testing.T) {
validRuleNicType := []string{"intranet", "internet"}
for _, v := range validRuleNicType {
_, errors := validateSecurityRuleNicType(v, "security_rule_nic_type")
if len(errors) != 0 {
t.Fatalf("%q should be a valid nic type: %q", v, errors)
}
}
invalidRuleNicType := []string{"inter", "ecmp", "http", "https"}
for _, v := range invalidRuleNicType {
_, errors := validateSecurityRuleNicType(v, "security_rule_nic_type")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid nic type", v)
}
}
}
func TestValidateSecurityRulePolicy(t *testing.T) {
validRulePolicy := []string{"accept", "drop"}
for _, v := range validRulePolicy {
_, errors := validateSecurityRulePolicy(v, "security_rule_policy")
if len(errors) != 0 {
t.Fatalf("%q should be a valid security rule policy: %q", v, errors)
}
}
invalidRulePolicy := []string{"inter", "ecmp", "http", "https"}
for _, v := range invalidRulePolicy {
_, errors := validateSecurityRulePolicy(v, "security_rule_policy")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid security rule policy", v)
}
}
}
func TestValidateSecurityRulePriority(t *testing.T) {
validPriority := []int{1, 50, 100}
for _, v := range validPriority {
_, errors := validateSecurityPriority(v, "security_rule_priority")
if len(errors) != 0 {
t.Fatalf("%q should be a valid security rule priority: %q", v, errors)
}
}
invalidPriority := []int{-1, 0, 101}
for _, v := range invalidPriority {
_, errors := validateSecurityPriority(v, "security_rule_priority")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid security rule priority", v)
}
}
}
func TestValidateCIDRNetworkAddress(t *testing.T) {
validCIDRNetworkAddress := []string{"192.168.10.0/24", "0.0.0.0/0", "10.121.10.0/24"}
for _, v := range validCIDRNetworkAddress {
_, errors := validateCIDRNetworkAddress(v, "cidr_network_address")
if len(errors) != 0 {
t.Fatalf("%q should be a valid cidr network address: %q", v, errors)
}
}
invalidCIDRNetworkAddress := []string{"1.2.3.4", "0x38732/21"}
for _, v := range invalidCIDRNetworkAddress {
_, errors := validateCIDRNetworkAddress(v, "cidr_network_address")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid cidr network address", v)
}
}
}
func TestValidateRouteEntryNextHopType(t *testing.T) {
validNexthopType := []string{"Instance", "Tunnel"}
for _, v := range validNexthopType {
_, errors := validateRouteEntryNextHopType(v, "route_entry_nexthop_type")
if len(errors) != 0 {
t.Fatalf("%q should be a valid route entry nexthop type: %q", v, errors)
}
}
invalidNexthopType := []string{"ri", "vpc"}
for _, v := range invalidNexthopType {
_, errors := validateRouteEntryNextHopType(v, "route_entry_nexthop_type")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid route entry nexthop type", v)
}
}
}
func TestValidateSwitchCIDRNetworkAddress(t *testing.T) {
validSwitchCIDRNetworkAddress := []string{"192.168.10.0/24", "0.0.0.0/16", "127.0.0.0/29", "10.121.10.0/24"}
for _, v := range validSwitchCIDRNetworkAddress {
_, errors := validateSwitchCIDRNetworkAddress(v, "switch_cidr_network_address")
if len(errors) != 0 {
t.Fatalf("%q should be a valid switch cidr network address: %q", v, errors)
}
}
invalidSwitchCIDRNetworkAddress := []string{"1.2.3.4", "0x38732/21", "10.121.10.0/15", "10.121.10.0/30", "256.121.10.0/22"}
for _, v := range invalidSwitchCIDRNetworkAddress {
_, errors := validateSwitchCIDRNetworkAddress(v, "switch_cidr_network_address")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid switch cidr network address", v)
}
}
}
func TestValidateIoOptimized(t *testing.T) {
validIoOptimized := []string{"", "none", "optimized"}
for _, v := range validIoOptimized {
_, errors := validateIoOptimized(v, "ioOptimized")
if len(errors) != 0 {
t.Fatalf("%q should be a valid IoOptimized value: %q", v, errors)
}
}
invalidIoOptimized := []string{"true", "ioOptimized"}
for _, v := range invalidIoOptimized {
_, errors := validateIoOptimized(v, "ioOptimized")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid IoOptimized value", v)
}
}
}
func TestValidateInstanceNetworkType(t *testing.T) {
validInstanceNetworkType := []string{"", "classic", "vpc"}
for _, v := range validInstanceNetworkType {
_, errors := validateInstanceNetworkType(v, "instance_network_type")
if len(errors) != 0 {
t.Fatalf("%q should be a valid instance network type value: %q", v, errors)
}
}
invalidInstanceNetworkType := []string{"Classic", "vswitch", "123"}
for _, v := range invalidInstanceNetworkType {
_, errors := validateInstanceNetworkType(v, "instance_network_type")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid instance network type value", v)
}
}
}
func TestValidateInstanceChargeType(t *testing.T) {
validInstanceChargeType := []string{"", "PrePaid", "PostPaid"}
for _, v := range validInstanceChargeType {
_, errors := validateInstanceChargeType(v, "instance_charge_type")
if len(errors) != 0 {
t.Fatalf("%q should be a valid instance charge type value: %q", v, errors)
}
}
invalidInstanceChargeType := []string{"prepay", "yearly", "123"}
for _, v := range invalidInstanceChargeType {
_, errors := validateInstanceChargeType(v, "instance_charge_type")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid instance charge type value", v)
}
}
}
func TestValidateInternetChargeType(t *testing.T) {
validInternetChargeType := []string{"", "PayByBandwidth", "PayByTraffic"}
for _, v := range validInternetChargeType {
_, errors := validateInternetChargeType(v, "internet_charge_type")
if len(errors) != 0 {
t.Fatalf("%q should be a valid internet charge type value: %q", v, errors)
}
}
invalidInternetChargeType := []string{"paybybandwidth", "paybytraffic", "123"}
for _, v := range invalidInternetChargeType {
_, errors := validateInternetChargeType(v, "internet_charge_type")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid internet charge type value", v)
}
}
}
func TestValidateInternetMaxBandWidthOut(t *testing.T) {
validInternetMaxBandWidthOut := []int{1, 22, 100}
for _, v := range validInternetMaxBandWidthOut {
_, errors := validateInternetMaxBandWidthOut(v, "internet_max_bandwidth_out")
if len(errors) != 0 {
t.Fatalf("%q should be a valid internet max bandwidth out value: %q", v, errors)
}
}
invalidInternetMaxBandWidthOut := []int{-2, 101, 123}
for _, v := range invalidInternetMaxBandWidthOut {
_, errors := validateInternetMaxBandWidthOut(v, "internet_max_bandwidth_out")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid internet max bandwidth out value", v)
}
}
}
func TestValidateSlbName(t *testing.T) {
validSlbName := []string{"h", "http://", "123", "hello, aliyun! "}
for _, v := range validSlbName {
_, errors := validateSlbName(v, "slb_name")
if len(errors) != 0 {
t.Fatalf("%q should be a valid slb name: %q", v, errors)
}
}
// todo: add invalid case
}
func TestValidateSlbInternetChargeType(t *testing.T) {
validSlbInternetChargeType := []string{"paybybandwidth", "paybytraffic"}
for _, v := range validSlbInternetChargeType {
_, errors := validateSlbInternetChargeType(v, "slb_internet_charge_type")
if len(errors) != 0 {
t.Fatalf("%q should be a valid slb internet charge type value: %q", v, errors)
}
}
invalidSlbInternetChargeType := []string{"PayByBandwidth", "PayByTraffic"}
for _, v := range invalidSlbInternetChargeType {
_, errors := validateSlbInternetChargeType(v, "slb_internet_charge_type")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid slb internet charge type value", v)
}
}
}
func TestValidateSlbBandwidth(t *testing.T) {
validSlbBandwidth := []int{1, 22, 1000}
for _, v := range validSlbBandwidth {
_, errors := validateSlbBandwidth(v, "slb_bandwidth")
if len(errors) != 0 {
t.Fatalf("%q should be a valid slb bandwidth value: %q", v, errors)
}
}
invalidSlbBandwidth := []int{-2, 0, 1001}
for _, v := range invalidSlbBandwidth {
_, errors := validateSlbBandwidth(v, "slb_bandwidth")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid slb bandwidth value", v)
}
}
}
func TestValidateSlbListenerBandwidth(t *testing.T) {
validSlbListenerBandwidth := []int{-1, 1, 22, 1000}
for _, v := range validSlbListenerBandwidth {
_, errors := validateSlbListenerBandwidth(v, "slb_bandwidth")
if len(errors) != 0 {
t.Fatalf("%q should be a valid slb listener bandwidth value: %q", v, errors)
}
}
invalidSlbListenerBandwidth := []int{-2, 0, -10, 1001}
for _, v := range invalidSlbListenerBandwidth {
_, errors := validateSlbListenerBandwidth(v, "slb_bandwidth")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid slb listener bandwidth value", v)
}
}
}
func TestValidateAllowedStringValue(t *testing.T) {
exceptValues := []string{"aliyun", "alicloud", "alibaba"}
validValues := []string{"aliyun"}
for _, v := range validValues {
_, errors := validateAllowedStringValue(exceptValues)(v, "allowvalue")
if len(errors) != 0 {
t.Fatalf("%q should be a valid value in %#v: %q", v, exceptValues, errors)
}
}
invalidValues := []string{"ali", "alidata", "terraform"}
for _, v := range invalidValues {
_, errors := validateAllowedStringValue(exceptValues)(v, "allowvalue")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid value", v)
}
}
}
func TestValidateAllowedStringSplitValue(t *testing.T) {
exceptValues := []string{"aliyun", "alicloud", "alibaba"}
validValues := "aliyun,alicloud"
_, errors := validateAllowedSplitStringValue(exceptValues, ",")(validValues, "allowvalue")
if len(errors) != 0 {
t.Fatalf("%q should be a valid value in %#v: %q", validValues, exceptValues, errors)
}
invalidValues := "ali,alidata"
_, invalidErr := validateAllowedSplitStringValue(exceptValues, ",")(invalidValues, "allowvalue")
if len(invalidErr) == 0 {
t.Fatalf("%q should be an invalid value", invalidValues)
}
}
func TestValidateAllowedIntValue(t *testing.T) {
exceptValues := []int{1, 3, 5, 6}
validValues := []int{1, 3, 5, 6}
for _, v := range validValues {
_, errors := validateAllowedIntValue(exceptValues)(v, "allowvalue")
if len(errors) != 0 {
t.Fatalf("%q should be a valid value in %#v: %q", v, exceptValues, errors)
}
}
invalidValues := []int{0, 7, 10}
for _, v := range invalidValues {
_, errors := validateAllowedIntValue(exceptValues)(v, "allowvalue")
if len(errors) == 0 {
t.Fatalf("%q should be an invalid value", v)
}
}
}
func TestValidateIntegerInRange(t *testing.T) {
validIntegers := []int{-259, 0, 1, 5, 999}
min := -259
max := 999
for _, v := range validIntegers {
_, errors := validateIntegerInRange(min, max)(v, "name")
if len(errors) != 0 {
t.Fatalf("%q should be an integer in range (%d, %d): %q", v, min, max, errors)
}
}
invalidIntegers := []int{-260, -99999, 1000, 25678}
for _, v := range invalidIntegers {
_, errors := validateIntegerInRange(min, max)(v, "name")
if len(errors) == 0 {
t.Fatalf("%q should be an integer outside range (%d, %d)", v, min, max)
}
}
}