databricksdataprotectionloadbalancermanagedapplications - rea…

…d id-style property insensitively (#20566)

internal/services/databricks/databricks_workspace_resource.go

@@ -599,7 +599,7 @@ func resourceDatabricksWorkspaceRead(d *pluginsdk.ResourceData, meta interface{}
 			d.Set("sku", sku.Name)
 		}
 
-		managedResourceGroupID, err := resourcesParse.ResourceGroupID(model.Properties.ManagedResourceGroupId)
+		managedResourceGroupID, err := resourcesParse.ResourceGroupIDInsensitively(model.Properties.ManagedResourceGroupId)
 		if err != nil {
 			return err
 		}
@@ -820,7 +820,7 @@ func flattenWorkspaceCustomParameters(input *workspaces.WorkspaceCustomParameter
 		parameters["virtual_network_id"] = v.Value
 	}
 
-	lbId, err := loadBalancerParse.LoadBalancerID(loadBalancerId)
+	lbId, err := loadBalancerParse.LoadBalancerIDInsensitively(loadBalancerId)
 
 	if err == nil {
 		backendId := loadBalancerParse.NewLoadBalancerBackendAddressPoolID(lbId.SubscriptionId, lbId.ResourceGroup, lbId.Name, backendName)

internal/services/dataprotection/data_protection_backup_instance_disk_resource.go

@@ -185,7 +185,7 @@ func resourceDataProtectionBackupInstanceDiskRead(d *schema.ResourceData, meta i
 				parameter := (*props.PolicyInfo.PolicyParameters.DataStoreParametersList)[0].(backupinstances.AzureOperationalStoreParameters)
 
 				if parameter.ResourceGroupId != nil {
-					resourceGroupId, err := resourceParse.ResourceGroupID(*parameter.ResourceGroupId)
+					resourceGroupId, err := resourceParse.ResourceGroupIDInsensitively(*parameter.ResourceGroupId)
 					if err != nil {
 						return err
 					}

internal/services/loadbalancer/nat_pool_resource.go

@@ -222,7 +222,7 @@ func resourceArmLoadBalancerNatPoolRead(d *pluginsdk.ResourceData, meta interfac
 		frontendIPConfigName := ""
 		frontendIPConfigID := ""
 		if props.FrontendIPConfiguration != nil && props.FrontendIPConfiguration.ID != nil {
-			feid, err := parse.LoadBalancerFrontendIpConfigurationID(*props.FrontendIPConfiguration.ID)
+			feid, err := parse.LoadBalancerFrontendIpConfigurationIDInsensitively(*props.FrontendIPConfiguration.ID)
 			if err != nil {
 				return err
 			}

internal/services/loadbalancer/nat_rule_resource.go

@@ -256,7 +256,7 @@ func resourceArmLoadBalancerNatRuleRead(d *pluginsdk.ResourceData, meta interfac
 		frontendIPConfigName := ""
 		frontendIPConfigID := ""
 		if props.FrontendIPConfiguration != nil && props.FrontendIPConfiguration.ID != nil {
-			feid, err := parse.LoadBalancerFrontendIpConfigurationID(*props.FrontendIPConfiguration.ID)
+			feid, err := parse.LoadBalancerFrontendIpConfigurationIDInsensitively(*props.FrontendIPConfiguration.ID)
 			if err != nil {
 				return err
 			}

internal/services/loadbalancer/outbound_rule_resource.go

@@ -218,7 +218,7 @@ func resourceArmLoadBalancerOutboundRuleRead(d *pluginsdk.ResourceData, meta int
 
 		backendAddressPoolId := ""
 		if props.BackendAddressPool != nil && props.BackendAddressPool.ID != nil {
-			bapid, err := parse.LoadBalancerBackendAddressPoolID(*props.BackendAddressPool.ID)
+			bapid, err := parse.LoadBalancerBackendAddressPoolIDInsensitively(*props.BackendAddressPool.ID)
 			if err != nil {
 				return err
 			}
@@ -234,7 +234,7 @@ func resourceArmLoadBalancerOutboundRuleRead(d *pluginsdk.ResourceData, meta int
 				if feConfig.ID == nil {
 					continue
 				}
-				feid, err := parse.LoadBalancerFrontendIpConfigurationID(*feConfig.ID)
+				feid, err := parse.LoadBalancerFrontendIpConfigurationIDInsensitively(*feConfig.ID)
 				if err != nil {
 					return err
 				}

internal/services/loadbalancer/parse/load_balancer.go

@@ -67,3 +67,47 @@ func LoadBalancerID(input string) (*LoadBalancerId, error) {
 
 	return &resourceId, nil
 }
+
+// LoadBalancerIDInsensitively parses an LoadBalancer ID into an LoadBalancerId struct, insensitively
+// This should only be used to parse an ID for rewriting, the LoadBalancerID
+// method should be used instead for validation etc.
+//
+// Whilst this may seem strange, this enables Terraform have consistent casing
+// which works around issues in Core, whilst handling broken API responses.
+func LoadBalancerIDInsensitively(input string) (*LoadBalancerId, error) {
+	id, err := resourceids.ParseAzureResourceID(input)
+	if err != nil {
+		return nil, err
+	}
+
+	resourceId := LoadBalancerId{
+		SubscriptionId: id.SubscriptionID,
+		ResourceGroup:  id.ResourceGroup,
+	}
+
+	if resourceId.SubscriptionId == "" {
+		return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
+	}
+
+	if resourceId.ResourceGroup == "" {
+		return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
+	}
+
+	// find the correct casing for the 'loadBalancers' segment
+	loadBalancersKey := "loadBalancers"
+	for key := range id.Path {
+		if strings.EqualFold(key, loadBalancersKey) {
+			loadBalancersKey = key
+			break
+		}
+	}
+	if resourceId.Name, err = id.PopSegment(loadBalancersKey); err != nil {
+		return nil, err
+	}
+
+	if err := id.ValidateNoEmptySegments(input); err != nil {
+		return nil, err
+	}
+
+	return &resourceId, nil
+}

internal/services/loadbalancer/parse/load_balancer_backend_address_pool.go

@@ -73,3 +73,59 @@ func LoadBalancerBackendAddressPoolID(input string) (*LoadBalancerBackendAddress
 
 	return &resourceId, nil
 }
+
+// LoadBalancerBackendAddressPoolIDInsensitively parses an LoadBalancerBackendAddressPool ID into an LoadBalancerBackendAddressPoolId struct, insensitively
+// This should only be used to parse an ID for rewriting, the LoadBalancerBackendAddressPoolID
+// method should be used instead for validation etc.
+//
+// Whilst this may seem strange, this enables Terraform have consistent casing
+// which works around issues in Core, whilst handling broken API responses.
+func LoadBalancerBackendAddressPoolIDInsensitively(input string) (*LoadBalancerBackendAddressPoolId, error) {
+	id, err := resourceids.ParseAzureResourceID(input)
+	if err != nil {
+		return nil, err
+	}
+
+	resourceId := LoadBalancerBackendAddressPoolId{
+		SubscriptionId: id.SubscriptionID,
+		ResourceGroup:  id.ResourceGroup,
+	}
+
+	if resourceId.SubscriptionId == "" {
+		return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
+	}
+
+	if resourceId.ResourceGroup == "" {
+		return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
+	}
+
+	// find the correct casing for the 'loadBalancers' segment
+	loadBalancersKey := "loadBalancers"
+	for key := range id.Path {
+		if strings.EqualFold(key, loadBalancersKey) {
+			loadBalancersKey = key
+			break
+		}
+	}
+	if resourceId.LoadBalancerName, err = id.PopSegment(loadBalancersKey); err != nil {
+		return nil, err
+	}
+
+	// find the correct casing for the 'backendAddressPools' segment
+	backendAddressPoolsKey := "backendAddressPools"
+	for key := range id.Path {
+		if strings.EqualFold(key, backendAddressPoolsKey) {
+			backendAddressPoolsKey = key
+			break
+		}
+	}
+	if resourceId.BackendAddressPoolName, err = id.PopSegment(backendAddressPoolsKey); err != nil {
+		return nil, err
+	}
+
+	if err := id.ValidateNoEmptySegments(input); err != nil {
+		return nil, err
+	}
+
+	return &resourceId, nil
+}

internal/services/loadbalancer/parse/load_balancer_backend_address_pool_test.go

@@ -126,3 +126,139 @@ func TestLoadBalancerBackendAddressPoolID(t *testing.T) {
 		}
 	}
 }
+
+func TestLoadBalancerBackendAddressPoolIDInsensitively(t *testing.T) {
+	testData := []struct {
+		Input    string
+		Error    bool
+		Expected *LoadBalancerBackendAddressPoolId
+	}{
+
+		{
+			// empty
+			Input: "",
+			Error: true,
+		},
+
+		{
+			// missing SubscriptionId
+			Input: "/",
+			Error: true,
+		},
+
+		{
+			// missing value for SubscriptionId
+			Input: "/subscriptions/",
+			Error: true,
+		},
+
+		{
+			// missing ResourceGroup
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
+			Error: true,
+		},
+
+		{
+			// missing value for ResourceGroup
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
+			Error: true,
+		},
+
+		{
+			// missing LoadBalancerName
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
+			Error: true,
+		},
+
+		{
+			// missing value for LoadBalancerName
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
+			Error: true,
+		},
+
+		{
+			// missing BackendAddressPoolName
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/",
+			Error: true,
+		},
+
+		{
+			// missing value for BackendAddressPoolName
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/backendAddressPools/",
+			Error: true,
+		},
+
+		{
+			// valid
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/backendAddressPools/backendAddressPool1",
+			Expected: &LoadBalancerBackendAddressPoolId{
+				SubscriptionId:         "12345678-1234-9876-4563-123456789012",
+				ResourceGroup:          "resGroup1",
+				LoadBalancerName:       "loadBalancer1",
+				BackendAddressPoolName: "backendAddressPool1",
+			},
+		},
+
+		{
+			// lower-cased segment names
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadbalancers/loadBalancer1/backendaddresspools/backendAddressPool1",
+			Expected: &LoadBalancerBackendAddressPoolId{
+				SubscriptionId:         "12345678-1234-9876-4563-123456789012",
+				ResourceGroup:          "resGroup1",
+				LoadBalancerName:       "loadBalancer1",
+				BackendAddressPoolName: "backendAddressPool1",
+			},
+		},
+
+		{
+			// upper-cased segment names
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/LOADBALANCERS/loadBalancer1/BACKENDADDRESSPOOLS/backendAddressPool1",
+			Expected: &LoadBalancerBackendAddressPoolId{
+				SubscriptionId:         "12345678-1234-9876-4563-123456789012",
+				ResourceGroup:          "resGroup1",
+				LoadBalancerName:       "loadBalancer1",
+				BackendAddressPoolName: "backendAddressPool1",
+			},
+		},
+
+		{
+			// mixed-cased segment names
+			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/LoAdBaLaNcErS/loadBalancer1/BaCkEnDaDdReSsPoOlS/backendAddressPool1",
+			Expected: &LoadBalancerBackendAddressPoolId{
+				SubscriptionId:         "12345678-1234-9876-4563-123456789012",
+				ResourceGroup:          "resGroup1",
+				LoadBalancerName:       "loadBalancer1",
+				BackendAddressPoolName: "backendAddressPool1",
+			},
+		},
+	}
+
+	for _, v := range testData {
+		t.Logf("[DEBUG] Testing %q", v.Input)
+
+		actual, err := LoadBalancerBackendAddressPoolIDInsensitively(v.Input)
+		if err != nil {
+			if v.Error {
+				continue
+			}
+
+			t.Fatalf("Expect a value but got an error: %s", err)
+		}
+		if v.Error {
+			t.Fatal("Expect an error but didn't get one")
+		}
+
+		if actual.SubscriptionId != v.Expected.SubscriptionId {
+			t.Fatalf("Expected %q but got %q for SubscriptionId", v.Expected.SubscriptionId, actual.SubscriptionId)
+		}
+		if actual.ResourceGroup != v.Expected.ResourceGroup {
+			t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup)
+		}
+		if actual.LoadBalancerName != v.Expected.LoadBalancerName {
+			t.Fatalf("Expected %q but got %q for LoadBalancerName", v.Expected.LoadBalancerName, actual.LoadBalancerName)
+		}
+		if actual.BackendAddressPoolName != v.Expected.BackendAddressPoolName {
+			t.Fatalf("Expected %q but got %q for BackendAddressPoolName", v.Expected.BackendAddressPoolName, actual.BackendAddressPoolName)
+		}
+	}
+}

internal/services/loadbalancer/parse/load_balancer_frontend_ip_configuration.go

@@ -73,3 +73,59 @@ func LoadBalancerFrontendIpConfigurationID(input string) (*LoadBalancerFrontendI
 
 	return &resourceId, nil
 }
+
+// LoadBalancerFrontendIpConfigurationIDInsensitively parses an LoadBalancerFrontendIpConfiguration ID into an LoadBalancerFrontendIpConfigurationId struct, insensitively
+// This should only be used to parse an ID for rewriting, the LoadBalancerFrontendIpConfigurationID
+// method should be used instead for validation etc.
+//
+// Whilst this may seem strange, this enables Terraform have consistent casing
+// which works around issues in Core, whilst handling broken API responses.
+func LoadBalancerFrontendIpConfigurationIDInsensitively(input string) (*LoadBalancerFrontendIpConfigurationId, error) {
+	id, err := resourceids.ParseAzureResourceID(input)
+	if err != nil {
+		return nil, err
+	}
+
+	resourceId := LoadBalancerFrontendIpConfigurationId{
+		SubscriptionId: id.SubscriptionID,
+		ResourceGroup:  id.ResourceGroup,
+	}
+
+	if resourceId.SubscriptionId == "" {
+		return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
+	}
+
+	if resourceId.ResourceGroup == "" {
+		return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
+	}
+
+	// find the correct casing for the 'loadBalancers' segment
+	loadBalancersKey := "loadBalancers"
+	for key := range id.Path {
+		if strings.EqualFold(key, loadBalancersKey) {
+			loadBalancersKey = key
+			break
+		}
+	}
+	if resourceId.LoadBalancerName, err = id.PopSegment(loadBalancersKey); err != nil {
+		return nil, err
+	}
+
+	// find the correct casing for the 'frontendIPConfigurations' segment
+	frontendIPConfigurationsKey := "frontendIPConfigurations"
+	for key := range id.Path {
+		if strings.EqualFold(key, frontendIPConfigurationsKey) {
+			frontendIPConfigurationsKey = key
+			break
+		}
+	}
+	if resourceId.FrontendIPConfigurationName, err = id.PopSegment(frontendIPConfigurationsKey); err != nil {
+		return nil, err
+	}
+
+	if err := id.ValidateNoEmptySegments(input); err != nil {
+		return nil, err
+	}
+
+	return &resourceId, nil
+}