github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/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 TestAccAzureRMLoadBalancerRule_disappears(t *testing.T) { 235 var lb network.LoadBalancer 236 ri := acctest.RandInt() 237 lbRuleName := fmt.Sprintf("LbRule-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) 238 239 resource.Test(t, resource.TestCase{ 240 PreCheck: func() { testAccPreCheck(t) }, 241 Providers: testAccProviders, 242 CheckDestroy: testCheckAzureRMLoadBalancerDestroy, 243 Steps: []resource.TestStep{ 244 { 245 Config: testAccAzureRMLoadBalancerRule_basic(ri, lbRuleName), 246 Check: resource.ComposeTestCheckFunc( 247 testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), 248 testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), 249 testCheckAzureRMLoadBalancerRuleDisappears(lbRuleName, &lb), 250 ), 251 ExpectNonEmptyPlan: true, 252 }, 253 }, 254 }) 255 } 256 257 func testCheckAzureRMLoadBalancerRuleExists(lbRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { 258 return func(s *terraform.State) error { 259 _, _, exists := findLoadBalancerRuleByName(lb, lbRuleName) 260 if !exists { 261 return fmt.Errorf("A LoadBalancer Rule with name %q cannot be found.", lbRuleName) 262 } 263 264 return nil 265 } 266 } 267 268 func testCheckAzureRMLoadBalancerRuleNotExists(lbRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { 269 return func(s *terraform.State) error { 270 _, _, exists := findLoadBalancerRuleByName(lb, lbRuleName) 271 if exists { 272 return fmt.Errorf("A LoadBalancer Rule with name %q has been found.", lbRuleName) 273 } 274 275 return nil 276 } 277 } 278 279 func testCheckAzureRMLoadBalancerRuleDisappears(ruleName string, lb *network.LoadBalancer) resource.TestCheckFunc { 280 return func(s *terraform.State) error { 281 conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient 282 283 _, i, exists := findLoadBalancerRuleByName(lb, ruleName) 284 if !exists { 285 return fmt.Errorf("A Rule with name %q cannot be found.", ruleName) 286 } 287 288 currentRules := *lb.LoadBalancerPropertiesFormat.LoadBalancingRules 289 rules := append(currentRules[:i], currentRules[i+1:]...) 290 lb.LoadBalancerPropertiesFormat.LoadBalancingRules = &rules 291 292 id, err := parseAzureResourceID(*lb.ID) 293 if err != nil { 294 return err 295 } 296 297 _, error := conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) 298 err = <-error 299 if err != nil { 300 return fmt.Errorf("Error Creating/Updating LoadBalancer %s", err) 301 } 302 303 _, err = conn.Get(id.ResourceGroup, *lb.Name, "") 304 return err 305 } 306 } 307 308 func testAccAzureRMLoadBalancerRule_basic(rInt int, lbRuleName string) string { 309 return fmt.Sprintf(` 310 resource "azurerm_resource_group" "test" { 311 name = "acctestrg-%d" 312 location = "West US" 313 } 314 315 resource "azurerm_public_ip" "test" { 316 name = "test-ip-%d" 317 location = "West US" 318 resource_group_name = "${azurerm_resource_group.test.name}" 319 public_ip_address_allocation = "static" 320 } 321 322 resource "azurerm_lb" "test" { 323 name = "arm-test-loadbalancer-%d" 324 location = "West US" 325 resource_group_name = "${azurerm_resource_group.test.name}" 326 327 frontend_ip_configuration { 328 name = "one-%d" 329 public_ip_address_id = "${azurerm_public_ip.test.id}" 330 } 331 } 332 333 resource "azurerm_lb_rule" "test" { 334 location = "West US" 335 resource_group_name = "${azurerm_resource_group.test.name}" 336 loadbalancer_id = "${azurerm_lb.test.id}" 337 name = "%s" 338 protocol = "Tcp" 339 frontend_port = 3389 340 backend_port = 3389 341 frontend_ip_configuration_name = "one-%d" 342 } 343 344 `, rInt, rInt, rInt, rInt, lbRuleName, rInt) 345 } 346 347 func testAccAzureRMLoadBalancerRule_removal(rInt int) string { 348 return fmt.Sprintf(` 349 resource "azurerm_resource_group" "test" { 350 name = "acctestrg-%d" 351 location = "West US" 352 } 353 354 resource "azurerm_public_ip" "test" { 355 name = "test-ip-%d" 356 location = "West US" 357 resource_group_name = "${azurerm_resource_group.test.name}" 358 public_ip_address_allocation = "static" 359 } 360 361 resource "azurerm_lb" "test" { 362 name = "arm-test-loadbalancer-%d" 363 location = "West US" 364 resource_group_name = "${azurerm_resource_group.test.name}" 365 366 frontend_ip_configuration { 367 name = "one-%d" 368 public_ip_address_id = "${azurerm_public_ip.test.id}" 369 } 370 } 371 `, rInt, rInt, rInt, rInt) 372 } 373 374 // https://github.com/hashicorp/terraform/issues/9424 375 func testAccAzureRMLoadBalancerRule_inconsistentRead(rInt int, backendPoolName, probeName, lbRuleName string) string { 376 return fmt.Sprintf(` 377 resource "azurerm_resource_group" "test" { 378 name = "acctestrg-%d" 379 location = "West US" 380 } 381 382 resource "azurerm_public_ip" "test" { 383 name = "test-ip-%d" 384 location = "West US" 385 resource_group_name = "${azurerm_resource_group.test.name}" 386 public_ip_address_allocation = "static" 387 } 388 389 resource "azurerm_lb" "test" { 390 name = "arm-test-loadbalancer-%d" 391 location = "West US" 392 resource_group_name = "${azurerm_resource_group.test.name}" 393 394 frontend_ip_configuration { 395 name = "one-%d" 396 public_ip_address_id = "${azurerm_public_ip.test.id}" 397 } 398 } 399 400 resource "azurerm_lb_backend_address_pool" "teset" { 401 name = "%s" 402 location = "West US" 403 resource_group_name = "${azurerm_resource_group.test.name}" 404 loadbalancer_id = "${azurerm_lb.test.id}" 405 } 406 407 resource "azurerm_lb_probe" "test" { 408 name = "%s" 409 location = "West US" 410 resource_group_name = "${azurerm_resource_group.test.name}" 411 loadbalancer_id = "${azurerm_lb.test.id}" 412 protocol = "Tcp" 413 port = 443 414 } 415 416 resource "azurerm_lb_rule" "test" { 417 name = "%s" 418 location = "West US" 419 resource_group_name = "${azurerm_resource_group.test.name}" 420 loadbalancer_id = "${azurerm_lb.test.id}" 421 protocol = "Tcp" 422 frontend_port = 3389 423 backend_port = 3389 424 frontend_ip_configuration_name = "one-%d" 425 } 426 `, rInt, rInt, rInt, rInt, backendPoolName, probeName, lbRuleName, rInt) 427 } 428 429 func testAccAzureRMLoadBalancerRule_multipleRules(rInt int, lbRuleName, lbRule2Name string) string { 430 return fmt.Sprintf(` 431 resource "azurerm_resource_group" "test" { 432 name = "acctestrg-%d" 433 location = "West US" 434 } 435 436 resource "azurerm_public_ip" "test" { 437 name = "test-ip-%d" 438 location = "West US" 439 resource_group_name = "${azurerm_resource_group.test.name}" 440 public_ip_address_allocation = "static" 441 } 442 443 resource "azurerm_lb" "test" { 444 name = "arm-test-loadbalancer-%d" 445 location = "West US" 446 resource_group_name = "${azurerm_resource_group.test.name}" 447 448 frontend_ip_configuration { 449 name = "one-%d" 450 public_ip_address_id = "${azurerm_public_ip.test.id}" 451 } 452 } 453 454 resource "azurerm_lb_rule" "test" { 455 location = "West US" 456 resource_group_name = "${azurerm_resource_group.test.name}" 457 loadbalancer_id = "${azurerm_lb.test.id}" 458 name = "%s" 459 protocol = "Udp" 460 frontend_port = 3389 461 backend_port = 3389 462 frontend_ip_configuration_name = "one-%d" 463 } 464 465 resource "azurerm_lb_rule" "test2" { 466 location = "West US" 467 resource_group_name = "${azurerm_resource_group.test.name}" 468 loadbalancer_id = "${azurerm_lb.test.id}" 469 name = "%s" 470 protocol = "Udp" 471 frontend_port = 3390 472 backend_port = 3390 473 frontend_ip_configuration_name = "one-%d" 474 } 475 476 `, rInt, rInt, rInt, rInt, lbRuleName, rInt, lbRule2Name, rInt) 477 } 478 479 func testAccAzureRMLoadBalancerRule_multipleRulesUpdate(rInt int, lbRuleName, lbRule2Name string) string { 480 return fmt.Sprintf(` 481 resource "azurerm_resource_group" "test" { 482 name = "acctestrg-%d" 483 location = "West US" 484 } 485 486 resource "azurerm_public_ip" "test" { 487 name = "test-ip-%d" 488 location = "West US" 489 resource_group_name = "${azurerm_resource_group.test.name}" 490 public_ip_address_allocation = "static" 491 } 492 493 resource "azurerm_lb" "test" { 494 name = "arm-test-loadbalancer-%d" 495 location = "West US" 496 resource_group_name = "${azurerm_resource_group.test.name}" 497 498 frontend_ip_configuration { 499 name = "one-%d" 500 public_ip_address_id = "${azurerm_public_ip.test.id}" 501 } 502 } 503 504 resource "azurerm_lb_rule" "test" { 505 location = "West US" 506 resource_group_name = "${azurerm_resource_group.test.name}" 507 loadbalancer_id = "${azurerm_lb.test.id}" 508 name = "%s" 509 protocol = "Udp" 510 frontend_port = 3389 511 backend_port = 3389 512 frontend_ip_configuration_name = "one-%d" 513 } 514 515 resource "azurerm_lb_rule" "test2" { 516 location = "West US" 517 resource_group_name = "${azurerm_resource_group.test.name}" 518 loadbalancer_id = "${azurerm_lb.test.id}" 519 name = "%s" 520 protocol = "Udp" 521 frontend_port = 3391 522 backend_port = 3391 523 frontend_ip_configuration_name = "one-%d" 524 } 525 526 `, rInt, rInt, rInt, rInt, lbRuleName, rInt, lbRule2Name, rInt) 527 }