From c104ce68153301ff8b4abb0dabda2eedab948085 Mon Sep 17 00:00:00 2001 From: Peter McAtominey Date: Tue, 31 Jan 2017 15:55:17 +0000 Subject: [PATCH] provider/azurerm: check if lb sub resources exist when reading (#11553) This fixes detection when a sub resource is deleted via the API or Portal --- ...e_arm_loadbalancer_backend_address_pool.go | 44 +++++++-------- ..._loadbalancer_backend_address_pool_test.go | 51 ++++++++++++++++++ .../resource_arm_loadbalancer_nat_pool.go | 27 +++++----- ...resource_arm_loadbalancer_nat_pool_test.go | 51 ++++++++++++++++++ .../resource_arm_loadbalancer_nat_rule.go | 31 ++++++----- ...resource_arm_loadbalancer_nat_rule_test.go | 51 ++++++++++++++++++ .../resource_arm_loadbalancer_probe.go | 25 +++++---- .../resource_arm_loadbalancer_probe_test.go | 51 ++++++++++++++++++ .../azurerm/resource_arm_loadbalancer_rule.go | 54 ++++++++++--------- .../resource_arm_loadbalancer_rule_test.go | 51 ++++++++++++++++++ 10 files changed, 345 insertions(+), 91 deletions(-) diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool.go b/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool.go index 143a797d5..3bb8b75d2 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool.go @@ -140,31 +140,31 @@ func resourceArmLoadBalancerBackendAddressPoolRead(d *schema.ResourceData, meta return nil } - configs := *loadBalancer.LoadBalancerPropertiesFormat.BackendAddressPools - for _, config := range configs { - if *config.Name == d.Get("name").(string) { - d.Set("name", config.Name) + config, _, exists := findLoadBalancerBackEndAddressPoolByName(loadBalancer, d.Get("name").(string)) + if !exists { + d.SetId("") + log.Printf("[INFO] LoadBalancer Backend Address Pool %q not found. Removing from state", d.Get("name").(string)) + return nil + } - if config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations != nil { - backend_ip_configurations := make([]string, 0, len(*config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations)) - for _, backendConfig := range *config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations { - backend_ip_configurations = append(backend_ip_configurations, *backendConfig.ID) - } + d.Set("name", config.Name) - d.Set("backend_ip_configurations", backend_ip_configurations) - } - - if config.BackendAddressPoolPropertiesFormat.LoadBalancingRules != nil { - load_balancing_rules := make([]string, 0, len(*config.BackendAddressPoolPropertiesFormat.LoadBalancingRules)) - for _, rule := range *config.BackendAddressPoolPropertiesFormat.LoadBalancingRules { - load_balancing_rules = append(load_balancing_rules, *rule.ID) - } - - d.Set("backend_ip_configurations", load_balancing_rules) - } - - break + if config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations != nil { + backend_ip_configurations := make([]string, 0, len(*config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations)) + for _, backendConfig := range *config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations { + backend_ip_configurations = append(backend_ip_configurations, *backendConfig.ID) } + + d.Set("backend_ip_configurations", backend_ip_configurations) + } + + if config.BackendAddressPoolPropertiesFormat.LoadBalancingRules != nil { + load_balancing_rules := make([]string, 0, len(*config.BackendAddressPoolPropertiesFormat.LoadBalancingRules)) + for _, rule := range *config.BackendAddressPoolPropertiesFormat.LoadBalancingRules { + load_balancing_rules = append(load_balancing_rules, *rule.ID) + } + + d.Set("backend_ip_configurations", load_balancing_rules) } return nil diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool_test.go b/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool_test.go index d612476bd..316fe2e9e 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool_test.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_backend_address_pool_test.go @@ -94,6 +94,29 @@ func TestAccAzureRMLoadBalancerBackEndAddressPool_reapply(t *testing.T) { }) } +func TestAccAzureRMLoadBalancerBackEndAddressPool_disappears(t *testing.T) { + var lb network.LoadBalancer + ri := acctest.RandInt() + addressPoolName := fmt.Sprintf("%d-address-pool", ri) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLoadBalancerDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLoadBalancerBackEndAddressPool_basic(ri, addressPoolName), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), + testCheckAzureRMLoadBalancerBackEndAddressPoolExists(addressPoolName, &lb), + testCheckAzureRMLoadBalancerBackEndAddressPoolDisappears(addressPoolName, &lb), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + func testCheckAzureRMLoadBalancerBackEndAddressPoolExists(addressPoolName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { _, _, exists := findLoadBalancerBackEndAddressPoolByName(lb, addressPoolName) @@ -116,6 +139,34 @@ func testCheckAzureRMLoadBalancerBackEndAddressPoolNotExists(addressPoolName str } } +func testCheckAzureRMLoadBalancerBackEndAddressPoolDisappears(addressPoolName string, lb *network.LoadBalancer) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + + _, i, exists := findLoadBalancerBackEndAddressPoolByName(lb, addressPoolName) + if !exists { + return fmt.Errorf("A BackEnd Address Pool with name %q cannot be found.", addressPoolName) + } + + currentPools := *lb.LoadBalancerPropertiesFormat.BackendAddressPools + pools := append(currentPools[:i], currentPools[i+1:]...) + lb.LoadBalancerPropertiesFormat.BackendAddressPools = &pools + + id, err := parseAzureResourceID(*lb.ID) + if err != nil { + return err + } + + _, err = conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %s", err) + } + + _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + return err + } +} + func testAccAzureRMLoadBalancerBackEndAddressPool_basic(rInt int, addressPoolName string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_nat_pool.go b/builtin/providers/azurerm/resource_arm_loadbalancer_nat_pool.go index aa797b635..a1cc4488c 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_nat_pool.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_nat_pool.go @@ -163,22 +163,21 @@ func resourceArmLoadBalancerNatPoolRead(d *schema.ResourceData, meta interface{} return nil } - configs := *loadBalancer.LoadBalancerPropertiesFormat.InboundNatPools - for _, config := range configs { - if *config.Name == d.Get("name").(string) { - d.Set("name", config.Name) + config, _, exists := findLoadBalancerNatPoolByName(loadBalancer, d.Get("name").(string)) + if !exists { + d.SetId("") + log.Printf("[INFO] LoadBalancer Nat Pool %q not found. Removing from state", d.Get("name").(string)) + return nil + } - d.Set("protocol", config.InboundNatPoolPropertiesFormat.Protocol) - d.Set("frontend_port_start", config.InboundNatPoolPropertiesFormat.FrontendPortRangeStart) - d.Set("frontend_port_end", config.InboundNatPoolPropertiesFormat.FrontendPortRangeEnd) - d.Set("backend_port", config.InboundNatPoolPropertiesFormat.BackendPort) + d.Set("name", config.Name) + d.Set("protocol", config.InboundNatPoolPropertiesFormat.Protocol) + d.Set("frontend_port_start", config.InboundNatPoolPropertiesFormat.FrontendPortRangeStart) + d.Set("frontend_port_end", config.InboundNatPoolPropertiesFormat.FrontendPortRangeEnd) + d.Set("backend_port", config.InboundNatPoolPropertiesFormat.BackendPort) - if config.InboundNatPoolPropertiesFormat.FrontendIPConfiguration != nil { - d.Set("frontend_ip_configuration_id", config.InboundNatPoolPropertiesFormat.FrontendIPConfiguration.ID) - } - - break - } + if config.InboundNatPoolPropertiesFormat.FrontendIPConfiguration != nil { + d.Set("frontend_ip_configuration_id", config.InboundNatPoolPropertiesFormat.FrontendIPConfiguration.ID) } return nil diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_nat_pool_test.go b/builtin/providers/azurerm/resource_arm_loadbalancer_nat_pool_test.go index ac001cb79..b64dd786b 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_nat_pool_test.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_nat_pool_test.go @@ -134,6 +134,29 @@ func TestAccAzureRMLoadBalancerNatPool_reapply(t *testing.T) { }) } +func TestAccAzureRMLoadBalancerNatPool_disappears(t *testing.T) { + var lb network.LoadBalancer + ri := acctest.RandInt() + natPoolName := fmt.Sprintf("NatPool-%d", ri) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLoadBalancerDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLoadBalancerNatPool_basic(ri, natPoolName), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), + testCheckAzureRMLoadBalancerNatPoolExists(natPoolName, &lb), + testCheckAzureRMLoadBalancerNatPoolDisappears(natPoolName, &lb), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + func testCheckAzureRMLoadBalancerNatPoolExists(natPoolName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { _, _, exists := findLoadBalancerNatPoolByName(lb, natPoolName) @@ -156,6 +179,34 @@ func testCheckAzureRMLoadBalancerNatPoolNotExists(natPoolName string, lb *networ } } +func testCheckAzureRMLoadBalancerNatPoolDisappears(natPoolName string, lb *network.LoadBalancer) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + + _, i, exists := findLoadBalancerNatPoolByName(lb, natPoolName) + if !exists { + return fmt.Errorf("A Nat Pool with name %q cannot be found.", natPoolName) + } + + currentPools := *lb.LoadBalancerPropertiesFormat.InboundNatPools + pools := append(currentPools[:i], currentPools[i+1:]...) + lb.LoadBalancerPropertiesFormat.InboundNatPools = &pools + + id, err := parseAzureResourceID(*lb.ID) + if err != nil { + return err + } + + _, err = conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %s", err) + } + + _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + return err + } +} + func testAccAzureRMLoadBalancerNatPool_basic(rInt int, natPoolName string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_nat_rule.go b/builtin/providers/azurerm/resource_arm_loadbalancer_nat_rule.go index ac3220811..662f090c1 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_nat_rule.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_nat_rule.go @@ -163,25 +163,24 @@ func resourceArmLoadBalancerNatRuleRead(d *schema.ResourceData, meta interface{} return nil } - configs := *loadBalancer.LoadBalancerPropertiesFormat.InboundNatRules - for _, config := range configs { - if *config.Name == d.Get("name").(string) { - d.Set("name", config.Name) + config, _, exists := findLoadBalancerNatRuleByName(loadBalancer, d.Get("name").(string)) + if !exists { + d.SetId("") + log.Printf("[INFO] LoadBalancer Nat Rule %q not found. Removing from state", d.Get("name").(string)) + return nil + } - d.Set("protocol", config.InboundNatRulePropertiesFormat.Protocol) - d.Set("frontend_port", config.InboundNatRulePropertiesFormat.FrontendPort) - d.Set("backend_port", config.InboundNatRulePropertiesFormat.BackendPort) + d.Set("name", config.Name) + d.Set("protocol", config.InboundNatRulePropertiesFormat.Protocol) + d.Set("frontend_port", config.InboundNatRulePropertiesFormat.FrontendPort) + d.Set("backend_port", config.InboundNatRulePropertiesFormat.BackendPort) - if config.InboundNatRulePropertiesFormat.FrontendIPConfiguration != nil { - d.Set("frontend_ip_configuration_id", config.InboundNatRulePropertiesFormat.FrontendIPConfiguration.ID) - } + if config.InboundNatRulePropertiesFormat.FrontendIPConfiguration != nil { + d.Set("frontend_ip_configuration_id", config.InboundNatRulePropertiesFormat.FrontendIPConfiguration.ID) + } - if config.InboundNatRulePropertiesFormat.BackendIPConfiguration != nil { - d.Set("backend_ip_configuration_id", config.InboundNatRulePropertiesFormat.BackendIPConfiguration.ID) - } - - break - } + if config.InboundNatRulePropertiesFormat.BackendIPConfiguration != nil { + d.Set("backend_ip_configuration_id", config.InboundNatRulePropertiesFormat.BackendIPConfiguration.ID) } return nil diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_nat_rule_test.go b/builtin/providers/azurerm/resource_arm_loadbalancer_nat_rule_test.go index b4ca2d23d..cfa4a65dd 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_nat_rule_test.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_nat_rule_test.go @@ -136,6 +136,29 @@ func TestAccAzureRMLoadBalancerNatRule_reapply(t *testing.T) { }) } +func TestAccAzureRMLoadBalancerNatRule_disappears(t *testing.T) { + var lb network.LoadBalancer + ri := acctest.RandInt() + natRuleName := fmt.Sprintf("NatRule-%d", ri) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLoadBalancerDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLoadBalancerNatRule_basic(ri, natRuleName), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), + testCheckAzureRMLoadBalancerNatRuleExists(natRuleName, &lb), + testCheckAzureRMLoadBalancerNatRuleDisappears(natRuleName, &lb), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + func testCheckAzureRMLoadBalancerNatRuleExists(natRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { _, _, exists := findLoadBalancerNatRuleByName(lb, natRuleName) @@ -158,6 +181,34 @@ func testCheckAzureRMLoadBalancerNatRuleNotExists(natRuleName string, lb *networ } } +func testCheckAzureRMLoadBalancerNatRuleDisappears(natRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + + _, i, exists := findLoadBalancerNatRuleByName(lb, natRuleName) + if !exists { + return fmt.Errorf("A Nat Rule with name %q cannot be found.", natRuleName) + } + + currentRules := *lb.LoadBalancerPropertiesFormat.InboundNatRules + rules := append(currentRules[:i], currentRules[i+1:]...) + lb.LoadBalancerPropertiesFormat.InboundNatRules = &rules + + id, err := parseAzureResourceID(*lb.ID) + if err != nil { + return err + } + + _, err = conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %s", err) + } + + _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + return err + } +} + func testAccAzureRMLoadBalancerNatRule_basic(rInt int, natRuleName string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_probe.go b/builtin/providers/azurerm/resource_arm_loadbalancer_probe.go index 0658a354d..c5678cec7 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_probe.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_probe.go @@ -168,21 +168,20 @@ func resourceArmLoadBalancerProbeRead(d *schema.ResourceData, meta interface{}) return nil } - configs := *loadBalancer.LoadBalancerPropertiesFormat.Probes - for _, config := range configs { - if *config.Name == d.Get("name").(string) { - d.Set("name", config.Name) - - d.Set("protocol", config.ProbePropertiesFormat.Protocol) - d.Set("interval_in_seconds", config.ProbePropertiesFormat.IntervalInSeconds) - d.Set("number_of_probes", config.ProbePropertiesFormat.NumberOfProbes) - d.Set("port", config.ProbePropertiesFormat.Port) - d.Set("request_path", config.ProbePropertiesFormat.RequestPath) - - break - } + config, _, exists := findLoadBalancerProbeByName(loadBalancer, d.Get("name").(string)) + if !exists { + d.SetId("") + log.Printf("[INFO] LoadBalancer Probe %q not found. Removing from state", d.Get("name").(string)) + return nil } + d.Set("name", config.Name) + d.Set("protocol", config.ProbePropertiesFormat.Protocol) + d.Set("interval_in_seconds", config.ProbePropertiesFormat.IntervalInSeconds) + d.Set("number_of_probes", config.ProbePropertiesFormat.NumberOfProbes) + d.Set("port", config.ProbePropertiesFormat.Port) + d.Set("request_path", config.ProbePropertiesFormat.RequestPath) + return nil } diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_probe_test.go b/builtin/providers/azurerm/resource_arm_loadbalancer_probe_test.go index dc30ba741..5f5f816db 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_probe_test.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_probe_test.go @@ -164,6 +164,29 @@ func TestAccAzureRMLoadBalancerProbe_reapply(t *testing.T) { }) } +func TestAccAzureRMLoadBalancerProbe_disappears(t *testing.T) { + var lb network.LoadBalancer + ri := acctest.RandInt() + probeName := fmt.Sprintf("probe-%d", ri) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLoadBalancerDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLoadBalancerProbe_basic(ri, probeName), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), + testCheckAzureRMLoadBalancerProbeExists(probeName, &lb), + testCheckAzureRMLoadBalancerProbeDisappears(probeName, &lb), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + func testCheckAzureRMLoadBalancerProbeExists(natRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { _, _, exists := findLoadBalancerProbeByName(lb, natRuleName) @@ -186,6 +209,34 @@ func testCheckAzureRMLoadBalancerProbeNotExists(natRuleName string, lb *network. } } +func testCheckAzureRMLoadBalancerProbeDisappears(addressPoolName string, lb *network.LoadBalancer) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + + _, i, exists := findLoadBalancerProbeByName(lb, addressPoolName) + if !exists { + return fmt.Errorf("A Probe with name %q cannot be found.", addressPoolName) + } + + currentProbes := *lb.LoadBalancerPropertiesFormat.Probes + probes := append(currentProbes[:i], currentProbes[i+1:]...) + lb.LoadBalancerPropertiesFormat.Probes = &probes + + id, err := parseAzureResourceID(*lb.ID) + if err != nil { + return err + } + + _, err = conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %s", err) + } + + _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + return err + } +} + func testAccAzureRMLoadBalancerProbe_basic(rInt int, probeName string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_rule.go b/builtin/providers/azurerm/resource_arm_loadbalancer_rule.go index 25a71f61e..67c5e3555 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_rule.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_rule.go @@ -190,39 +190,41 @@ func resourceArmLoadBalancerRuleRead(d *schema.ResourceData, meta interface{}) e return nil } - configs := *loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules - for _, config := range configs { - if *config.Name == d.Get("name").(string) { - d.Set("name", config.Name) + config, _, exists := findLoadBalancerRuleByName(loadBalancer, d.Get("name").(string)) + if !exists { + d.SetId("") + log.Printf("[INFO] LoadBalancer Rule %q not found. Removing from state", d.Get("name").(string)) + return nil + } - d.Set("protocol", config.LoadBalancingRulePropertiesFormat.Protocol) - d.Set("frontend_port", config.LoadBalancingRulePropertiesFormat.FrontendPort) - d.Set("backend_port", config.LoadBalancingRulePropertiesFormat.BackendPort) + d.Set("name", config.Name) - if config.LoadBalancingRulePropertiesFormat.EnableFloatingIP != nil { - d.Set("enable_floating_ip", config.LoadBalancingRulePropertiesFormat.EnableFloatingIP) - } + d.Set("protocol", config.LoadBalancingRulePropertiesFormat.Protocol) + d.Set("frontend_port", config.LoadBalancingRulePropertiesFormat.FrontendPort) + d.Set("backend_port", config.LoadBalancingRulePropertiesFormat.BackendPort) - if config.LoadBalancingRulePropertiesFormat.IdleTimeoutInMinutes != nil { - d.Set("idle_timeout_in_minutes", config.LoadBalancingRulePropertiesFormat.IdleTimeoutInMinutes) - } + if config.LoadBalancingRulePropertiesFormat.EnableFloatingIP != nil { + d.Set("enable_floating_ip", config.LoadBalancingRulePropertiesFormat.EnableFloatingIP) + } - if config.LoadBalancingRulePropertiesFormat.FrontendIPConfiguration != nil { - d.Set("frontend_ip_configuration_id", config.LoadBalancingRulePropertiesFormat.FrontendIPConfiguration.ID) - } + if config.LoadBalancingRulePropertiesFormat.IdleTimeoutInMinutes != nil { + d.Set("idle_timeout_in_minutes", config.LoadBalancingRulePropertiesFormat.IdleTimeoutInMinutes) + } - if config.LoadBalancingRulePropertiesFormat.BackendAddressPool != nil { - d.Set("backend_address_pool_id", config.LoadBalancingRulePropertiesFormat.BackendAddressPool.ID) - } + if config.LoadBalancingRulePropertiesFormat.FrontendIPConfiguration != nil { + d.Set("frontend_ip_configuration_id", config.LoadBalancingRulePropertiesFormat.FrontendIPConfiguration.ID) + } - if config.LoadBalancingRulePropertiesFormat.Probe != nil { - d.Set("probe_id", config.LoadBalancingRulePropertiesFormat.Probe.ID) - } + if config.LoadBalancingRulePropertiesFormat.BackendAddressPool != nil { + d.Set("backend_address_pool_id", config.LoadBalancingRulePropertiesFormat.BackendAddressPool.ID) + } - if config.LoadBalancingRulePropertiesFormat.LoadDistribution != "" { - d.Set("load_distribution", config.LoadBalancingRulePropertiesFormat.LoadDistribution) - } - } + if config.LoadBalancingRulePropertiesFormat.Probe != nil { + d.Set("probe_id", config.LoadBalancingRulePropertiesFormat.Probe.ID) + } + + if config.LoadBalancingRulePropertiesFormat.LoadDistribution != "" { + d.Set("load_distribution", config.LoadBalancingRulePropertiesFormat.LoadDistribution) } return nil diff --git a/builtin/providers/azurerm/resource_arm_loadbalancer_rule_test.go b/builtin/providers/azurerm/resource_arm_loadbalancer_rule_test.go index aa15a66e5..3a3a7dd4d 100644 --- a/builtin/providers/azurerm/resource_arm_loadbalancer_rule_test.go +++ b/builtin/providers/azurerm/resource_arm_loadbalancer_rule_test.go @@ -231,6 +231,29 @@ func TestAccAzureRMLoadBalancerRule_reapply(t *testing.T) { }) } +func TestAccAzureRMLoadBalancerRule_disappears(t *testing.T) { + var lb network.LoadBalancer + ri := acctest.RandInt() + lbRuleName := fmt.Sprintf("LbRule-%s", acctest.RandStringFromCharSet(8, acctest.CharSetAlpha)) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLoadBalancerDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLoadBalancerRule_basic(ri, lbRuleName), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), + testCheckAzureRMLoadBalancerRuleExists(lbRuleName, &lb), + testCheckAzureRMLoadBalancerRuleDisappears(lbRuleName, &lb), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + func testCheckAzureRMLoadBalancerRuleExists(lbRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { _, _, exists := findLoadBalancerRuleByName(lb, lbRuleName) @@ -253,6 +276,34 @@ func testCheckAzureRMLoadBalancerRuleNotExists(lbRuleName string, lb *network.Lo } } +func testCheckAzureRMLoadBalancerRuleDisappears(ruleName string, lb *network.LoadBalancer) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + + _, i, exists := findLoadBalancerRuleByName(lb, ruleName) + if !exists { + return fmt.Errorf("A Rule with name %q cannot be found.", ruleName) + } + + currentRules := *lb.LoadBalancerPropertiesFormat.LoadBalancingRules + rules := append(currentRules[:i], currentRules[i+1:]...) + lb.LoadBalancerPropertiesFormat.LoadBalancingRules = &rules + + id, err := parseAzureResourceID(*lb.ID) + if err != nil { + return err + } + + _, err = conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %s", err) + } + + _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + return err + } +} + func testAccAzureRMLoadBalancerRule_basic(rInt int, lbRuleName string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" {