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  }