github.com/pbthorste/terraform@v0.8.6-0.20170127005045-deb56bd93da2/builtin/providers/azurerm/resource_arm_loadbalancer_rule_test.go (about) 1 package azurerm 2 3 import ( 4 "fmt" 5 "os" 6 "testing" 7 8 "github.com/Azure/azure-sdk-for-go/arm/network" 9 "github.com/hashicorp/terraform/helper/acctest" 10 "github.com/hashicorp/terraform/helper/resource" 11 "github.com/hashicorp/terraform/terraform" 12 ) 13 14 func TestResourceAzureRMLoadBalancerRuleNameLabel_validation(t *testing.T) { 15 cases := []struct { 16 Value string 17 ErrCount int 18 }{ 19 { 20 Value: "-word", 21 ErrCount: 1, 22 }, 23 { 24 Value: "testing-", 25 ErrCount: 1, 26 }, 27 { 28 Value: "test#test", 29 ErrCount: 1, 30 }, 31 { 32 Value: acctest.RandStringFromCharSet(81, "abcdedfed"), 33 ErrCount: 1, 34 }, 35 { 36 Value: "test.rule", 37 ErrCount: 0, 38 }, 39 { 40 Value: "test_rule", 41 ErrCount: 0, 42 }, 43 { 44 Value: "test-rule", 45 ErrCount: 0, 46 }, 47 { 48 Value: "TestRule", 49 ErrCount: 0, 50 }, 51 { 52 Value: "Test123Rule", 53 ErrCount: 0, 54 }, 55 { 56 Value: "TestRule", 57 ErrCount: 0, 58 }, 59 } 60 61 for _, tc := range cases { 62 _, errors := validateArmLoadBalancerRuleName(tc.Value, "azurerm_lb_rule") 63 64 if len(errors) != tc.ErrCount { 65 t.Fatalf("Expected the Azure RM LoadBalancer Rule Name Label to trigger a validation error") 66 } 67 } 68 } 69 70 func TestAccAzureRMLoadBalancerRule_basic(t *testing.T) { 71 var lb network.LoadBalancer 72 ri := acctest.RandInt() 73 lbRuleName := fmt.Sprintf("LbRule-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 74 75 subscriptionID := os.Getenv("ARM_SUBSCRIPTION_ID") 76 lbRule_id := fmt.Sprintf( 77 "/subscriptions/%s/resourceGroups/acctestrg-%d/providers/Microsoft.Network/loadBalancers/arm-test-loadbalancer-%d/loadBalancingRules/%s", 78 subscriptionID, ri, ri, lbRuleName) 79 80 resource.Test(t, resource.TestCase{ 81 PreCheck: func() { testAccPreCheck(t) }, 82 Providers: testAccProviders, 83 CheckDestroy: testCheckAzureRMLoadBalancerDestroy, 84 Steps: []resource.TestStep{ 85 { 86 Config: testAccAzureRMLoadBalancerRule_basic(ri, lbRuleName), 87 Check: resource.ComposeTestCheckFunc( 88 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 89 testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), 90 resource.TestCheckResourceAttr( 91 "azurerm_lb_rule.test", "id", lbRule_id), 92 ), 93 }, 94 }, 95 }) 96 } 97 98 func TestAccAzureRMLoadBalancerRule_removal(t *testing.T) { 99 var lb network.LoadBalancer 100 ri := acctest.RandInt() 101 lbRuleName := fmt.Sprintf("LbRule-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 102 103 resource.Test(t, resource.TestCase{ 104 PreCheck: func() { testAccPreCheck(t) }, 105 Providers: testAccProviders, 106 CheckDestroy: testCheckAzureRMLoadBalancerDestroy, 107 Steps: []resource.TestStep{ 108 { 109 Config: testAccAzureRMLoadBalancerRule_basic(ri, lbRuleName), 110 Check: resource.ComposeTestCheckFunc( 111 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 112 testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), 113 ), 114 }, 115 { 116 Config: testAccAzureRMLoadBalancerRule_removal(ri), 117 Check: resource.ComposeTestCheckFunc( 118 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 119 testCheckAzureRMLoadBalancerRuleNotExists(lbRuleName, &lb), 120 ), 121 }, 122 }, 123 }) 124 } 125 126 // https://github.com/hashicorp/terraform/issues/9424 127 func TestAccAzureRMLoadBalancerRule_inconsistentReads(t *testing.T) { 128 var lb network.LoadBalancer 129 ri := acctest.RandInt() 130 backendPoolName := fmt.Sprintf("LbPool-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 131 lbRuleName := fmt.Sprintf("LbRule-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 132 probeName := fmt.Sprintf("LbProbe-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 133 134 resource.Test(t, resource.TestCase{ 135 PreCheck: func() { testAccPreCheck(t) }, 136 Providers: testAccProviders, 137 CheckDestroy: testCheckAzureRMLoadBalancerDestroy, 138 Steps: []resource.TestStep{ 139 { 140 Config: testAccAzureRMLoadBalancerRule_inconsistentRead(ri, backendPoolName, probeName, lbRuleName), 141 Check: resource.ComposeTestCheckFunc( 142 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 143 testCheckAzureRMLoadBalancerBackEndAddressPoolExists(backendPoolName, &lb), 144 testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), 145 testCheckAzureRMLoadBalancerProbeExists(probeName, &lb), 146 ), 147 }, 148 }, 149 }) 150 } 151 152 func TestAccAzureRMLoadBalancerRule_update(t *testing.T) { 153 var lb network.LoadBalancer 154 ri := acctest.RandInt() 155 lbRuleName := fmt.Sprintf("LbRule-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 156 lbRule2Name := fmt.Sprintf("LbRule-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 157 158 subscriptionID := os.Getenv("ARM_SUBSCRIPTION_ID") 159 lbRuleID := fmt.Sprintf( 160 "/subscriptions/%s/resourceGroups/acctestrg-%d/providers/Microsoft.Network/loadBalancers/arm-test-loadbalancer-%d/loadBalancingRules/%s", 161 subscriptionID, ri, ri, lbRuleName) 162 163 lbRule2ID := fmt.Sprintf( 164 "/subscriptions/%s/resourceGroups/acctestrg-%d/providers/Microsoft.Network/loadBalancers/arm-test-loadbalancer-%d/loadBalancingRules/%s", 165 subscriptionID, ri, ri, lbRule2Name) 166 167 resource.Test(t, resource.TestCase{ 168 PreCheck: func() { testAccPreCheck(t) }, 169 Providers: testAccProviders, 170 CheckDestroy: testCheckAzureRMLoadBalancerDestroy, 171 Steps: []resource.TestStep{ 172 { 173 Config: testAccAzureRMLoadBalancerRule_multipleRules(ri, lbRuleName, lbRule2Name), 174 Check: resource.ComposeTestCheckFunc( 175 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 176 testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), 177 testCheckAzureRMLoadBalancerRuleExists(lbRule2Name, &lb), 178 resource.TestCheckResourceAttr("azurerm_lb_rule.test", "id", lbRuleID), 179 resource.TestCheckResourceAttr("azurerm_lb_rule.test2", "id", lbRule2ID), 180 resource.TestCheckResourceAttr("azurerm_lb_rule.test2", "frontend_port", "3390"), 181 resource.TestCheckResourceAttr("azurerm_lb_rule.test2", "backend_port", "3390"), 182 ), 183 }, 184 { 185 Config: testAccAzureRMLoadBalancerRule_multipleRulesUpdate(ri, lbRuleName, lbRule2Name), 186 Check: resource.ComposeTestCheckFunc( 187 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 188 testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), 189 testCheckAzureRMLoadBalancerRuleExists(lbRule2Name, &lb), 190 resource.TestCheckResourceAttr("azurerm_lb_rule.test", "id", lbRuleID), 191 resource.TestCheckResourceAttr("azurerm_lb_rule.test2", "id", lbRule2ID), 192 resource.TestCheckResourceAttr("azurerm_lb_rule.test2", "frontend_port", "3391"), 193 resource.TestCheckResourceAttr("azurerm_lb_rule.test2", "backend_port", "3391"), 194 ), 195 }, 196 }, 197 }) 198 } 199 200 func TestAccAzureRMLoadBalancerRule_reapply(t *testing.T) { 201 var lb network.LoadBalancer 202 ri := acctest.RandInt() 203 lbRuleName := fmt.Sprintf("LbRule-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 204 205 deleteRuleState := func(s *terraform.State) error { 206 return s.Remove("azurerm_lb_rule.test") 207 } 208 209 resource.Test(t, resource.TestCase{ 210 PreCheck: func() { testAccPreCheck(t) }, 211 Providers: testAccProviders, 212 CheckDestroy: testCheckAzureRMLoadBalancerDestroy, 213 Steps: []resource.TestStep{ 214 { 215 Config: testAccAzureRMLoadBalancerRule_basic(ri, lbRuleName), 216 Check: resource.ComposeTestCheckFunc( 217 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 218 testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), 219 deleteRuleState, 220 ), 221 ExpectNonEmptyPlan: true, 222 }, 223 { 224 Config: testAccAzureRMLoadBalancerRule_basic(ri, lbRuleName), 225 Check: resource.ComposeTestCheckFunc( 226 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 227 testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), 228 ), 229 }, 230 }, 231 }) 232 } 233 234 func testCheckAzureRMLoadBalancerRuleExists(lbRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { 235 return func(s *terraform.State) error { 236 _, _, exists := findLoadBalancerRuleByName(lb, lbRuleName) 237 if !exists { 238 return fmt.Errorf("A LoadBalancer Rule with name %q cannot be found.", lbRuleName) 239 } 240 241 return nil 242 } 243 } 244 245 func testCheckAzureRMLoadBalancerRuleNotExists(lbRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { 246 return func(s *terraform.State) error { 247 _, _, exists := findLoadBalancerRuleByName(lb, lbRuleName) 248 if exists { 249 return fmt.Errorf("A LoadBalancer Rule with name %q has been found.", lbRuleName) 250 } 251 252 return nil 253 } 254 } 255 256 func testAccAzureRMLoadBalancerRule_basic(rInt int, lbRuleName string) string { 257 return fmt.Sprintf(` 258 resource "azurerm_resource_group" "test" { 259 name = "acctestrg-%d" 260 location = "West US" 261 } 262 263 resource "azurerm_public_ip" "test" { 264 name = "test-ip-%d" 265 location = "West US" 266 resource_group_name = "${azurerm_resource_group.test.name}" 267 public_ip_address_allocation = "static" 268 } 269 270 resource "azurerm_lb" "test" { 271 name = "arm-test-loadbalancer-%d" 272 location = "West US" 273 resource_group_name = "${azurerm_resource_group.test.name}" 274 275 frontend_ip_configuration { 276 name = "one-%d" 277 public_ip_address_id = "${azurerm_public_ip.test.id}" 278 } 279 } 280 281 resource "azurerm_lb_rule" "test" { 282 location = "West US" 283 resource_group_name = "${azurerm_resource_group.test.name}" 284 loadbalancer_id = "${azurerm_lb.test.id}" 285 name = "%s" 286 protocol = "Tcp" 287 frontend_port = 3389 288 backend_port = 3389 289 frontend_ip_configuration_name = "one-%d" 290 } 291 292 `, rInt, rInt, rInt, rInt, lbRuleName, rInt) 293 } 294 295 func testAccAzureRMLoadBalancerRule_removal(rInt int) string { 296 return fmt.Sprintf(` 297 resource "azurerm_resource_group" "test" { 298 name = "acctestrg-%d" 299 location = "West US" 300 } 301 302 resource "azurerm_public_ip" "test" { 303 name = "test-ip-%d" 304 location = "West US" 305 resource_group_name = "${azurerm_resource_group.test.name}" 306 public_ip_address_allocation = "static" 307 } 308 309 resource "azurerm_lb" "test" { 310 name = "arm-test-loadbalancer-%d" 311 location = "West US" 312 resource_group_name = "${azurerm_resource_group.test.name}" 313 314 frontend_ip_configuration { 315 name = "one-%d" 316 public_ip_address_id = "${azurerm_public_ip.test.id}" 317 } 318 } 319 `, rInt, rInt, rInt, rInt) 320 } 321 322 // https://github.com/hashicorp/terraform/issues/9424 323 func testAccAzureRMLoadBalancerRule_inconsistentRead(rInt int, backendPoolName, probeName, lbRuleName string) string { 324 return fmt.Sprintf(` 325 resource "azurerm_resource_group" "test" { 326 name = "acctestrg-%d" 327 location = "West US" 328 } 329 330 resource "azurerm_public_ip" "test" { 331 name = "test-ip-%d" 332 location = "West US" 333 resource_group_name = "${azurerm_resource_group.test.name}" 334 public_ip_address_allocation = "static" 335 } 336 337 resource "azurerm_lb" "test" { 338 name = "arm-test-loadbalancer-%d" 339 location = "West US" 340 resource_group_name = "${azurerm_resource_group.test.name}" 341 342 frontend_ip_configuration { 343 name = "one-%d" 344 public_ip_address_id = "${azurerm_public_ip.test.id}" 345 } 346 } 347 348 resource "azurerm_lb_backend_address_pool" "teset" { 349 name = "%s" 350 location = "West US" 351 resource_group_name = "${azurerm_resource_group.test.name}" 352 loadbalancer_id = "${azurerm_lb.test.id}" 353 } 354 355 resource "azurerm_lb_probe" "test" { 356 name = "%s" 357 location = "West US" 358 resource_group_name = "${azurerm_resource_group.test.name}" 359 loadbalancer_id = "${azurerm_lb.test.id}" 360 protocol = "Tcp" 361 port = 443 362 } 363 364 resource "azurerm_lb_rule" "test" { 365 name = "%s" 366 location = "West US" 367 resource_group_name = "${azurerm_resource_group.test.name}" 368 loadbalancer_id = "${azurerm_lb.test.id}" 369 protocol = "Tcp" 370 frontend_port = 3389 371 backend_port = 3389 372 frontend_ip_configuration_name = "one-%d" 373 } 374 `, rInt, rInt, rInt, rInt, backendPoolName, probeName, lbRuleName, rInt) 375 } 376 377 func testAccAzureRMLoadBalancerRule_multipleRules(rInt int, lbRuleName, lbRule2Name string) string { 378 return fmt.Sprintf(` 379 resource "azurerm_resource_group" "test" { 380 name = "acctestrg-%d" 381 location = "West US" 382 } 383 384 resource "azurerm_public_ip" "test" { 385 name = "test-ip-%d" 386 location = "West US" 387 resource_group_name = "${azurerm_resource_group.test.name}" 388 public_ip_address_allocation = "static" 389 } 390 391 resource "azurerm_lb" "test" { 392 name = "arm-test-loadbalancer-%d" 393 location = "West US" 394 resource_group_name = "${azurerm_resource_group.test.name}" 395 396 frontend_ip_configuration { 397 name = "one-%d" 398 public_ip_address_id = "${azurerm_public_ip.test.id}" 399 } 400 } 401 402 resource "azurerm_lb_rule" "test" { 403 location = "West US" 404 resource_group_name = "${azurerm_resource_group.test.name}" 405 loadbalancer_id = "${azurerm_lb.test.id}" 406 name = "%s" 407 protocol = "Udp" 408 frontend_port = 3389 409 backend_port = 3389 410 frontend_ip_configuration_name = "one-%d" 411 } 412 413 resource "azurerm_lb_rule" "test2" { 414 location = "West US" 415 resource_group_name = "${azurerm_resource_group.test.name}" 416 loadbalancer_id = "${azurerm_lb.test.id}" 417 name = "%s" 418 protocol = "Udp" 419 frontend_port = 3390 420 backend_port = 3390 421 frontend_ip_configuration_name = "one-%d" 422 } 423 424 `, rInt, rInt, rInt, rInt, lbRuleName, rInt, lbRule2Name, rInt) 425 } 426 427 func testAccAzureRMLoadBalancerRule_multipleRulesUpdate(rInt int, lbRuleName, lbRule2Name string) string { 428 return fmt.Sprintf(` 429 resource "azurerm_resource_group" "test" { 430 name = "acctestrg-%d" 431 location = "West US" 432 } 433 434 resource "azurerm_public_ip" "test" { 435 name = "test-ip-%d" 436 location = "West US" 437 resource_group_name = "${azurerm_resource_group.test.name}" 438 public_ip_address_allocation = "static" 439 } 440 441 resource "azurerm_lb" "test" { 442 name = "arm-test-loadbalancer-%d" 443 location = "West US" 444 resource_group_name = "${azurerm_resource_group.test.name}" 445 446 frontend_ip_configuration { 447 name = "one-%d" 448 public_ip_address_id = "${azurerm_public_ip.test.id}" 449 } 450 } 451 452 resource "azurerm_lb_rule" "test" { 453 location = "West US" 454 resource_group_name = "${azurerm_resource_group.test.name}" 455 loadbalancer_id = "${azurerm_lb.test.id}" 456 name = "%s" 457 protocol = "Udp" 458 frontend_port = 3389 459 backend_port = 3389 460 frontend_ip_configuration_name = "one-%d" 461 } 462 463 resource "azurerm_lb_rule" "test2" { 464 location = "West US" 465 resource_group_name = "${azurerm_resource_group.test.name}" 466 loadbalancer_id = "${azurerm_lb.test.id}" 467 name = "%s" 468 protocol = "Udp" 469 frontend_port = 3391 470 backend_port = 3391 471 frontend_ip_configuration_name = "one-%d" 472 } 473 474 `, rInt, rInt, rInt, rInt, lbRuleName, rInt, lbRule2Name, rInt) 475 }