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  }