automation: split automation_connection_certificate CreateUpdate into separate Create and Update (#31932)

Author: katbyte

internal/services/automation/automation_connection_certificate_resource.go

@@ -22,9 +22,9 @@ import (
 
 func resourceAutomationConnectionCertificate() *pluginsdk.Resource {
 	return &pluginsdk.Resource{
-		Create: resourceAutomationConnectionCertificateCreateUpdate,
+		Create: resourceAutomationConnectionCertificateCreate,
 		Read:   resourceAutomationConnectionCertificateRead,
-		Update: resourceAutomationConnectionCertificateCreateUpdate,
+		Update: resourceAutomationConnectionCertificateUpdate,
 		Delete: resourceAutomationConnectionCertificateDelete,
 
 		Importer: pluginsdk.ImporterValidatingResourceIdThen(func(id string) error {
@@ -76,32 +76,25 @@ func resourceAutomationConnectionCertificate() *pluginsdk.Resource {
 	}
 }
 
-func resourceAutomationConnectionCertificateCreateUpdate(d *pluginsdk.ResourceData, meta interface{}) error {
+func resourceAutomationConnectionCertificateCreate(d *pluginsdk.ResourceData, meta interface{}) error {
 	client := meta.(*clients.Client).Automation.Connection
 	subscriptionId := meta.(*clients.Client).Account.SubscriptionId
-	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
+	ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
 	log.Printf("[INFO] preparing arguments for AzureRM Automation Connection creation.")
 
 	id := connection.NewConnectionID(subscriptionId, d.Get("resource_group_name").(string), d.Get("automation_account_name").(string), d.Get("name").(string))
 
-	if d.IsNewResource() {
-		existing, err := client.Get(ctx, id)
-		if err != nil {
-			if !response.WasNotFound(existing.HttpResponse) {
-				return fmt.Errorf("checking for presence of existing %s: %s", id, err)
-			}
-		}
-
+	existing, err := client.Get(ctx, id)
+	if err != nil {
 		if !response.WasNotFound(existing.HttpResponse) {
-			return tf.ImportAsExistsError("azurerm_automation_connection_certificate", id.ID())
+			return fmt.Errorf("checking for presence of existing %s: %s", id, err)
 		}
 	}
 
-	fieldDefinitionValues := map[string]string{
-		"AutomationCertificateName": d.Get("automation_certificate_name").(string),
-		"SubscriptionID":            d.Get("subscription_id").(string),
+	if !response.WasNotFound(existing.HttpResponse) {
+		return tf.ImportAsExistsError("azurerm_automation_connection_certificate", id.ID())
 	}
 
 	parameters := connection.ConnectionCreateOrUpdateParameters{
@@ -111,19 +104,70 @@ func resourceAutomationConnectionCertificateCreateUpdate(d *pluginsdk.ResourceDa
 			ConnectionType: connection.ConnectionTypeAssociationProperty{
 				Name: pointer.To("Azure"),
 			},
-			FieldDefinitionValues: &fieldDefinitionValues,
+			FieldDefinitionValues: &map[string]string{
+				"AutomationCertificateName": d.Get("automation_certificate_name").(string),
+				"SubscriptionID":            d.Get("subscription_id").(string),
+			},
 		},
 	}
 
 	if _, err := client.CreateOrUpdate(ctx, id, parameters); err != nil {
-		return err
+		return fmt.Errorf("creating %s: %+v", id, err)
 	}
 
 	d.SetId(id.ID())
 
 	return resourceAutomationConnectionCertificateRead(d, meta)
 }
 
+func resourceAutomationConnectionCertificateUpdate(d *pluginsdk.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Automation.Connection
+	ctx, cancel := timeouts.ForUpdate(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := connection.ParseConnectionID(d.Id())
+	if err != nil {
+		return err
+	}
+
+	existing, err := client.Get(ctx, *id)
+	if err != nil {
+		return fmt.Errorf("retrieving existing %s: %+v", *id, err)
+	}
+
+	// Start from the existing field definition values so that fields managed
+	// via ignore_changes retain their server-side value.
+	fieldDefinitionValues := make(map[string]string)
+	if existing.Model != nil && existing.Model.Properties != nil && existing.Model.Properties.FieldDefinitionValues != nil {
+		fieldDefinitionValues = *existing.Model.Properties.FieldDefinitionValues
+	}
+
+	if d.HasChange("automation_certificate_name") {
+		fieldDefinitionValues["AutomationCertificateName"] = d.Get("automation_certificate_name").(string)
+	}
+
+	if d.HasChange("subscription_id") {
+		fieldDefinitionValues["SubscriptionID"] = d.Get("subscription_id").(string)
+	}
+
+	parameters := connection.ConnectionUpdateParameters{
+		Name: &id.ConnectionName,
+		Properties: &connection.ConnectionUpdateProperties{
+			FieldDefinitionValues: &fieldDefinitionValues,
+		},
+	}
+
+	if d.HasChange("description") {
+		parameters.Properties.Description = pointer.To(d.Get("description").(string))
+	}
+
+	if _, err := client.Update(ctx, *id, parameters); err != nil {
+		return fmt.Errorf("updating %s: %+v", *id, err)
+	}
+
+	return resourceAutomationConnectionCertificateRead(d, meta)
+}
+
 func resourceAutomationConnectionCertificateRead(d *pluginsdk.ResourceData, meta interface{}) error {
 	client := meta.(*clients.Client).Automation.Connection
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)