Repository: bpg/terraform-provider-proxmox

Issue:
scsi0 recreated when try to edit scsi1
**Describe the bug**
scsi0 drive recreated for VM when i try to increase size for scsi1

**To Reproduce**
Steps to reproduce the behavior:

1. Create a VM with 2 scsi drives. scsi0 are `import_from` and size 6Gb, scsi1 empty drive and size 1GB
2. Update scsi1 drive size from 1 to 2
3. Run terragrunt apply and got error `Error: error updating VM: received an HTTP 400 response - Reason: Parameter verification failed. (scsi0: hotplug problem - can't unplug bootdisk 'scsi0')`. In proxmox web UI i see some changes (see screenshot)

Please also provide a minimal Terraform configuration that reproduces the issue.

<details>
  <summary>main.ft</summary>

```hcl
resource "proxmox_virtual_environment_vm" "this" {
  name      = var.bpg_name
  description = var.bpg_desc
  node_name = var.bpg_target_node
  migrate = var.bpg_migrate
  pool_id = var.bpg_pool_id
  tags = var.bpg_tags
  agent {
    enabled = var.bpg_agent
  }
  cpu {
    cores = var.bpg_cpu.cores
    type = var.bpg_cpu.type
  }
  
  memory {
    dedicated = var.bpg_memory.dedicated
    floating  = var.bpg_memory.floating
  }

  initialization {
    datastore_id = var.bpg_initialization_datastore_id
    ip_config {
      ipv4 {
        address = var.bpg_initialization_ipconfig.ipv4.address
        gateway = var.bpg_initialization_ipconfig.ipv4.gateway
      }
    }
    dynamic "user_account" {
      for_each = var.bpg_initialization_user_account
      content {
        username = user_account.value.username
        password = user_account.value.password
        keys = user_account.value.keys
      }
    }
  }

  dynamic "disk" {
    for_each = var.bpg_disks
    content {
      datastore_id = disk.value.datastore_id
      import_from  = disk.value.import_from
      interface    = disk.key
      size         = disk.value.size
    }
  }

  dynamic "network_device" {
    for_each = var.bpg_network_device
    content {
      bridge = network_device.value.bridge
      model = network_device.value.model
    }
  }
}
```

</details>

<details>
  <summary>provider.ft</summary>

```hcl
provider "proxmox" {
  endpoint = var.pm_api_url
}
```

</details>

<details>
  <summary>variables.ft</summary>

```hcl
variable "pm_api_url" {
  description = "proxmox cluster api url"
  type        = string
}

variable "bpg_name" {
  description = "Required The name of the VM within Proxmox"
  type        = string
  default     = ""
  validation {
    condition     = length(var.bpg_name) > 0
    error_message = "The name variable value must be set"
  }
}

variable "bpg_desc" {
  type = string
  default = "Managed by Terraform"
}

variable "bpg_target_node" {
  description = "Required The name of the Proxmox Node on which to place the VM"
  type        = string
  default     = ""
  validation {
    condition     = length(var.bpg_target_node) > 0
    error_message = "The target_node variable value must be set"
  }
}

variable "bpg_migrate" {
  type = bool
  default = true
}

variable "bpg_cpu" {
  type = object({
    cores = optional(number)
    type = optional(string)
  })
  default = {
    cores = 1
    type = "qemu64"
  }
}

variable "bpg_memory" {
  type = object({
    dedicated = number
    floating = optional(number)
  })
  default = {
    dedicated = 512
  }
}

variable "bpg_pool_id" {
  type = string
  default = null
}

variable "bpg_tags" {
  type = any
  default = []
}

variable "bpg_disks" {
  type = map(object({
    datastore_id = string
    import_from = optional(string)
    size = number
  }))
  default = {
    "scsi0" = {
      datastore_id = "local"
      import_from = null
      size = 5
    }
  }
}

variable "bpg_initialization_datastore_id" {
  type = string
  default = "ssd1t-01"
}

variable "bpg_initialization_ipconfig" {
  type = object({
    ipv4 = optional(object({
      address = optional(string)
      gateway = optional(string)
    }))
  })
  default = {
    ipv4 = {
      address = "dhcp"
    }
  }
}

variable "bpg_initialization_user_account" {
  type = list(object({
    username = optional(string)
    password = optional(string)
    keys = optional(any)
  }))
  default = []
  validation {
    condition     = length(var.bpg_initialization_user_account) <= 1
    error_message = "You must specify only one user"
  }
}

variable "bpg_network_device" {
  type = list(object({
    bridge = string
    model = optional(string)
  }))
  default = [ {
    bridge = "vmbr0"
    model = "virtio"
  } ]
}

variable "bpg_agent" {
  type = bool
  default = true
}
```

</details>

<details>
  <summary>versions.ft</summary>

```hcl
terraform {
  required_providers {
    proxmox = {
      source = "bpg/proxmox"
      version = "0.82.0"
    }
  }
}
```

</details>

<details>
  <summary>terragrunt.ft</summary>

```hcl
locals {
  # Automatically load account-level variables
  env_vars     = read_terragrunt_config(find_in_parent_folders("env.hcl"))
  cluster_vars = read_terragrunt_config(find_in_parent_folders("cluster.hcl"))
  current_node = basename(get_terragrunt_dir())
}

terraform {
  source = "${get_parent_terragrunt_dir()}//modules/proxmox-vm-bpg"
}

include {
  path = find_in_parent_folders("root.hcl")
}

dependency "pve_talos_image" {
  config_path = "${get_parent_terragrunt_dir()}/providers/on-prem/infra/pve01/config/images/talos/v1.10.6"
}

inputs = {
  bpg_name           = "${basename(get_terragrunt_dir())}.${local.env_vars.locals.default_dns_domain}"
  bpg_desc           = local.env_vars.locals.desc
  bpg_target_node    = local.cluster_vars.locals.controlplanes_data.nodes[local.current_node].pve_node
  bpg_cpu = {
    cores          = local.env_vars.locals.k8s_default_cores
    type            = local.cluster_vars.locals.vm.cpu
  }
  bpg_memory = {
    dedicated         = local.env_vars.locals.k8s_default_control_memory
  }
  bpg_pool_id           = local.cluster_vars.locals.talos.cluster_name
  bpg_tags           = local.cluster_vars.locals.vm.tags
  bpg_initialization_ipconfig = {
      ipv4 = {
        address = "${local.cluster_vars.locals.controlplanes_data.nodes[local.current_node].ip_address}/26"
        gateway = "${local.cluster_vars.locals.vm.default_gateway}"
      }
    }
  bpg_initialization_user_account = [{
      username = "huz"
  }]
  bpg_disks = {
    "scsi0" = {
      size    = 6
      datastore_id = "ssd1t-01"
      import_from    = dependency.pve_talos_image.outputs.pve_talos_image
    },
    "scsi1" = {
      size    = 2
      datastore_id = "ssd1t-01"
    }
  }
  bpg_network_device = [
    {
      bridge = "vmbr3"
      model  = "virtio"
    }
  ]
}

```

</details>

and the output of `terraform|tofu apply`.
```text
terragrunt apply -auto-approve
18:23:24.429 STDOUT terraform: proxmox_virtual_environment_vm.this: Refreshing state... [id=100]
18:23:25.072 STDOUT terraform: Terraform used the selected providers to generate the following execution
18:23:25.072 STDOUT terraform: plan. Resource actions are indicated with the following symbols:
18:23:25.072 STDOUT terraform:   ~ update in-place
18:23:25.072 STDOUT terraform: Terraform will perform the following actions:
18:23:25.072 STDOUT terraform:   # proxmox_virtual_environment_vm.this will be updated in-place
18:23:25.072 STDOUT terraform:   ~ resource "proxmox_virtual_environment_vm" "this" {
18:23:25.072 STDOUT terraform:         id                      = "100"
18:23:25.073 STDOUT terraform:         name                    = "k8s03-c04.gekatabraids.com"
18:23:25.073 STDOUT terraform:         tags                    = [
18:23:25.073 STDOUT terraform:             "infra",
18:23:25.073 STDOUT terraform:             "k8s03",
18:23:25.073 STDOUT terraform:         ]
18:23:25.073 STDOUT terraform:         # (31 unchanged attributes hidden)
18:23:25.073 STDOUT terraform:       ~ disk {
18:23:25.073 STDOUT terraform:           ~ size              = 1 -> 2
18:23:25.073 STDOUT terraform:             # (14 unchanged attributes hidden)
18:23:25.073 STDOUT terraform:         }
18:23:25.073 STDOUT terraform:         # (6 unchanged blocks hidden)
18:23:25.073 STDOUT terraform:     }
18:23:25.073 STDOUT terraform: Plan: 0 to add, 1 to change, 0 to destroy.
18:23:25.073 STDOUT terraform: 
18:23:25.126 STDOUT terraform: proxmox_virtual_environment_vm.this: Modifying... [id=100]
18:23:26.764 STDERR terraform: ╷
18:23:26.764 STDERR terraform: │ Error: error updating VM: received an HTTP 400 response - Reason: Parameter verification failed. (scsi0: hotplug problem - can't unplug bootdisk 'scsi0')
18:23:26.764 STDERR terraform: │ 
18:23:26.765 STDERR terraform: │   with proxmox_virtual_environment_vm.this,
18:23:26.765 STDERR terraform: │   on main.tf line 1, in resource "proxmox_virtual_environment_vm" "this":
18:23:26.766 STDERR terraform: │    1: resource "proxmox_virtual_environment_vm" "this" {
18:23:26.766 STDERR terraform: │ 
18:23:26.766 STDERR terraform: ╵
18:23:26.774 ERROR  terraform invocation failed in ./.terragrunt-cache/0J0m8TP4S8XCOyp4kjyxlVPA4Ko/ueDx9ptB3Gcbx_Z0TnuhXOHnfD8/modules/proxmox-vm-bpg
18:23:26.775 ERROR  error occurred:

* Failed to execute "terraform apply -auto-approve" in ./.terragrunt-cache/0J0m8TP4S8XCOyp4kjyxlVPA4Ko/ueDx9ptB3Gcbx_Z0TnuhXOHnfD8/modules/proxmox-vm-bpg
  ╷
  │ Error: error updating VM: received an HTTP 400 response - Reason: Parameter verification failed. (scsi0: hotplug problem - can't unplug bootdisk 'scsi0')
  │ 
  │   with proxmox_virtual_environment_vm.this,
  │   on main.tf line 1, in resource "proxmox_virtual_environment_vm" "this":
  │    1: resource "proxmox_virtual_environment_vm" "this" {
  │ 
  ╵
  
  exit status 1
```

**Expected behavior**
scsi0 stay untouched. scsi1 drive sise increased.

**Screenshots**
<img width="969" height="167" alt="Image" src="https://github.com/user-attachments/assets/9ef7217f-4c4c-4c4d-970b-f3ff3f869541" />

**Additional context**
Add any other context about the problem here.

- Single or clustered Proxmox: 2 node cluster
- Proxmox version: 8.4.11/14a32011146091ed
- Provider version (ideally it should be the latest version): 0.82.0
- Terraform/OpenTofu version: v1.12.1
- OS (where you run Terraform/OpenTofu from): mac os 15.6
- Debug logs (`TF_LOG=DEBUG terraform apply`):


Hints from issue comments:
@bpg: Hey @huziahmetovsv 👋🏼 

Thanks for the detailed report! 
I think this ticket is the same as #2060, so I'm going to close it.
@huziahmetovsv: yep, 0.82.1 works fine, thanks!

Solution patch:
diff --git a/proxmox/nodes/vms/custom_storage_device.go b/proxmox/nodes/vms/custom_storage_device.go
index f82dc758..5a211477 100644
--- a/proxmox/nodes/vms/custom_storage_device.go
+++ b/proxmox/nodes/vms/custom_storage_device.go
@@ -442,3 +442,32 @@ func (d CustomStorageDevices) EncodeValues(_ string, v *url.Values) error {
 
 	return nil
 }
+
+// Equals compares two CustomStorageDevice instances to determine if they are equal.
+// It compares all fields that could trigger an update.
+func (d *CustomStorageDevice) Equals(other *CustomStorageDevice) bool {
+	if d == nil || other == nil {
+		return false
+	}
+
+	// Compare all fields that could trigger an update
+	return ptr.Eq(d.AIO, other.AIO) &&
+		ptr.Eq(d.Backup, other.Backup) &&
+		ptr.Eq(d.BurstableReadSpeedMbps, other.BurstableReadSpeedMbps) &&
+		ptr.Eq(d.BurstableWriteSpeedMbps, other.BurstableWriteSpeedMbps) &&
+		ptr.Eq(d.Cache, other.Cache) &&
+		ptr.Eq(d.DatastoreID, other.DatastoreID) &&
+		ptr.Eq(d.Discard, other.Discard) &&
+		ptr.Eq(d.ImportFrom, other.ImportFrom) &&
+		ptr.Eq(d.IOThread, other.IOThread) &&
+		ptr.Eq(d.IopsRead, other.IopsRead) &&
+		ptr.Eq(d.IopsWrite, other.IopsWrite) &&
+		ptr.Eq(d.MaxIopsRead, other.MaxIopsRead) &&
+		ptr.Eq(d.MaxIopsWrite, other.MaxIopsWrite) &&
+		ptr.Eq(d.MaxReadSpeedMbps, other.MaxReadSpeedMbps) &&
+		ptr.Eq(d.MaxWriteSpeedMbps, other.MaxWriteSpeedMbps) &&
+		ptr.Eq(d.Replicate, other.Replicate) &&
+		ptr.Eq(d.Serial, other.Serial) &&
+		ptr.Eq(d.Size, other.Size) &&
+		ptr.Eq(d.SSD, other.SSD)
+}
diff --git a/proxmoxtf/resource/vm/disk/disk.go b/proxmoxtf/resource/vm/disk/disk.go
index 3e6ee446..53a1a647 100644
--- a/proxmoxtf/resource/vm/disk/disk.go
+++ b/proxmoxtf/resource/vm/disk/disk.go
@@ -602,6 +602,11 @@ func Update(
 					tmp = disk
 				}
 			case currentDisks[iface] != nil:
+				// Check if the disk has actually changed before updating
+				if currentDisks[iface].Equals(disk) {
+					// Disk hasn't changed, skip update
+					continue
+				}
 				// update existing disk
 				tmp = currentDisks[iface]
 			default:
@@ -618,12 +623,8 @@ func Update(
 				tmp.AIO = disk.AIO
 			}
 
-			if disk.ImportFrom != nil && *disk.ImportFrom != "" {
-				rebootRequired = true
-				tmp.DatastoreID = disk.DatastoreID
-				tmp.ImportFrom = disk.ImportFrom
-				tmp.Size = disk.Size
-			}
+			// Never send ImportFrom for existing disks - it triggers re-import which fails for boot disks
+			// ImportFrom is only for initial disk creation, not updates
 
 			tmp.Backup = disk.Backup
 			tmp.BurstableReadSpeedMbps = disk.BurstableReadSpeedMbps



Test patch:
diff --git a/fwprovider/test/resource_vm_disks_test.go b/fwprovider/test/resource_vm_disks_test.go
index 0714a2a3..0f7b6815 100644
--- a/fwprovider/test/resource_vm_disks_test.go
+++ b/fwprovider/test/resource_vm_disks_test.go
@@ -827,6 +827,138 @@ func TestAccResourceVMDisks(t *testing.T) {
 				}),
 			),
 		}}},
+		{"update single disk without affecting boot disk with import_from", []resource.TestStep{
+			{
+				// Create VM with boot disk that has import_from and a second disk
+				Config: te.RenderConfig(`
+				resource "proxmox_virtual_environment_download_file" "test_boot_image" {
+					content_type = "import"
+					datastore_id = "local"
+					node_name    = "{{.NodeName}}"
+					url          = "{{.CloudImagesServer}}/jammy/current/jammy-server-cloudimg-amd64.img"
+					file_name    = "test-bootdisk-bug-image.img.raw"
+					overwrite_unmanaged = true
+				}
+				resource "proxmox_virtual_environment_vm" "test_bootdisk_bug" {
+					node_name = "{{.NodeName}}"
+					started   = false
+					name 	  = "test-bootdisk-bug"
+					
+					disk {
+						datastore_id = "local-lvm"
+						import_from  = proxmox_virtual_environment_download_file.test_boot_image.id
+						interface    = "scsi0"
+						size         = 6
+					}
+					
+					disk {
+						datastore_id = "local-lvm" 
+						interface    = "scsi1"
+						size         = 1
+					}
+				}`),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("proxmox_virtual_environment_vm.test_bootdisk_bug", "disk.0.interface", "scsi0"),
+					resource.TestCheckResourceAttr("proxmox_virtual_environment_vm.test_bootdisk_bug", "disk.1.interface", "scsi1"),
+					resource.TestCheckResourceAttr("proxmox_virtual_environment_vm.test_bootdisk_bug", "disk.1.size", "1"),
+				),
+			},
+			{
+				// Update only scsi1 size from 1 to 2
+				Config: te.RenderConfig(`
+				resource "proxmox_virtual_environment_download_file" "test_boot_image" {
+					content_type = "import"
+					datastore_id = "local"
+					node_name    = "{{.NodeName}}"
+					url          = "{{.CloudImagesServer}}/jammy/current/jammy-server-cloudimg-amd64.img"
+					file_name    = "test-bootdisk-bug-image.img.raw"
+					overwrite_unmanaged = true
+				}
+				resource "proxmox_virtual_environment_vm" "test_bootdisk_bug" {
+					node_name = "{{.NodeName}}"
+					started   = false
+					name 	  = "test-bootdisk-bug"
+					
+					disk {
+						datastore_id = "local-lvm"
+						import_from  = proxmox_virtual_environment_download_file.test_boot_image.id
+						interface    = "scsi0"
+						size         = 6  // UNCHANGED - should not be sent to API
+					}
+					
+					disk {
+						datastore_id = "local-lvm"
+						interface    = "scsi1"
+						size         = 2  // CHANGED - only this should be sent to API
+					}
+				}`),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction("proxmox_virtual_environment_vm.test_bootdisk_bug", plancheck.ResourceActionUpdate),
+					},
+				},
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("proxmox_virtual_environment_vm.test_bootdisk_bug", "disk.1.size", "2"),
+				),
+			},
+		}},
+		{"resize boot disk with import_from should not trigger re-import", []resource.TestStep{
+			{
+				// Create VM with boot disk using import_from
+				Config: te.RenderConfig(`
+				resource "proxmox_virtual_environment_download_file" "test_boot_resize" {
+					content_type = "import"
+					datastore_id = "local"
+					node_name    = "{{.NodeName}}"
+					url          = "{{.CloudImagesServer}}/jammy/current/jammy-server-cloudimg-amd64.img"
+					file_name    = "test-boot-resize-image.img.raw"
+					overwrite_unmanaged = true
+				}
+				resource "proxmox_virtual_environment_vm" "test_boot_resize" {
+					node_name = "{{.NodeName}}"
+					started   = false
+					name 	  = "test-boot-resize"
+					
+					disk {
+						datastore_id = "local-lvm"
+						import_from  = proxmox_virtual_environment_download_file.test_boot_resize.id
+						interface    = "scsi0"
+						size         = 8
+					}
+				}`),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("proxmox_virtual_environment_vm.test_boot_resize", "disk.0.interface", "scsi0"),
+					resource.TestCheckResourceAttrSet("proxmox_virtual_environment_vm.test_boot_resize", "disk.0.path_in_datastore"),
+				),
+			},
+			{
+				// Resize the boot disk itself
+				Config: te.RenderConfig(`
+				resource "proxmox_virtual_environment_download_file" "test_boot_resize" {
+					content_type = "import"
+					datastore_id = "local"
+					node_name    = "{{.NodeName}}"
+					url          = "{{.CloudImagesServer}}/jammy/current/jammy-server-cloudimg-amd64.img"
+					file_name    = "test-boot-resize-image.img.raw"
+					overwrite_unmanaged = true
+				}
+				resource "proxmox_virtual_environment_vm" "test_boot_resize" {
+					node_name = "{{.NodeName}}"
+					started   = false
+					name 	  = "test-boot-resize"
+					
+					disk {
+						datastore_id = "local-lvm"
+						import_from  = proxmox_virtual_environment_download_file.test_boot_resize.id
+						interface    = "scsi0"
+						size         = 12  // Resize from 8 to 12 - should work now
+					}
+				}`),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("proxmox_virtual_environment_vm.test_boot_resize", "disk.0.size", "12"),
+				),
+			},
+		}},
 	}
 
 	for _, tt := range tests {
diff --git a/proxmoxtf/resource/vm/disk/disk_test.go b/proxmoxtf/resource/vm/disk/disk_test.go
index 94801356..3708770a 100644
--- a/proxmoxtf/resource/vm/disk/disk_test.go
+++ b/proxmoxtf/resource/vm/disk/disk_test.go
@@ -188,3 +188,164 @@ func TestDiskOrderingVariousInterfaces(t *testing.T) {
 			"Disk at position %d should be %s (as in currentDiskList)", i, expectedInterface)
 	}
 }
+
+// TestDiskDevicesEqual tests the disk Equals method to ensure proper comparison.
+func TestDiskDevicesEqual(t *testing.T) {
+	t.Parallel()
+
+	// Test nil cases
+	var nilDisk *vms.CustomStorageDevice
+	require.False(t, nilDisk.Equals(nil))
+	require.False(t, nilDisk.Equals(&vms.CustomStorageDevice{}))
+	require.False(t, (&vms.CustomStorageDevice{}).Equals(nil))
+
+	// Create identical disks
+	aio1 := "io_uring"
+	aio2 := "io_uring"
+	cache1 := "writeback"
+	cache2 := "writeback"
+	size1 := types.DiskSizeFromGigabytes(10)
+	size2 := types.DiskSizeFromGigabytes(10)
+	datastore1 := "local"
+	datastore2 := "local"
+
+	disk1 := &vms.CustomStorageDevice{
+		AIO:         &aio1,
+		Cache:       &cache1,
+		Size:        size1,
+		DatastoreID: &datastore1,
+	}
+
+	disk2 := &vms.CustomStorageDevice{
+		AIO:         &aio2,
+		Cache:       &cache2,
+		Size:        size2,
+		DatastoreID: &datastore2,
+	}
+
+	// Test identical disks
+	require.True(t, disk1.Equals(disk2))
+
+	// Test different AIO
+	aio2Changed := "native"
+	disk2Changed := &vms.CustomStorageDevice{
+		AIO:         &aio2Changed,
+		Cache:       &cache2,
+		Size:        size2,
+		DatastoreID: &datastore2,
+	}
+	require.False(t, disk1.Equals(disk2Changed))
+
+	// Test different size
+	size2Changed := types.DiskSizeFromGigabytes(20)
+	disk2SizeChanged := &vms.CustomStorageDevice{
+		AIO:         &aio2,
+		Cache:       &cache2,
+		Size:        size2Changed,
+		DatastoreID: &datastore2,
+	}
+	require.False(t, disk1.Equals(disk2SizeChanged))
+}
+
+// TestDiskUpdateSkipsUnchangedDisks tests that the Update function only updates changed disks.
+func TestDiskUpdateSkipsUnchangedDisks(t *testing.T) {
+	t.Parallel()
+
+	// Mock resource data
+	diskSchema := Schema()
+
+	var err error
+
+	resourceData := schema.TestResourceDataRaw(t, diskSchema, map[string]interface{}{
+		MkDisk: []interface{}{
+			map[string]interface{}{
+				mkDiskInterface:   "scsi0",
+				mkDiskDatastoreID: "local",
+				mkDiskSize:        10,
+				mkDiskImportFrom:  "local:iso/disk.qcow2",
+				mkDiskSpeed:       []interface{}{},
+			},
+			map[string]interface{}{
+				mkDiskInterface:   "scsi1",
+				mkDiskDatastoreID: "local",
+				mkDiskSize:        20,
+				mkDiskSpeed:       []interface{}{},
+			},
+		},
+	})
+
+	// Mark that the disk configuration has changed (terraform detected a change)
+	resourceData.MarkNewResource()
+
+	// Create current disks (what Proxmox currently has)
+	importFrom := "local:iso/disk.qcow2"
+	datastoreID := "local"
+	currentDisks := vms.CustomStorageDevices{
+		"scsi0": &vms.CustomStorageDevice{
+			Size:        types.DiskSizeFromGigabytes(10),
+			DatastoreID: &datastoreID,
+			ImportFrom:  &importFrom,
+		},
+		"scsi1": &vms.CustomStorageDevice{
+			Size:        types.DiskSizeFromGigabytes(5), // This is different (current=5, plan=20)
+			DatastoreID: &datastoreID,
+		},
+	}
+
+	// Create plan disks (what terraform wants)
+	planDisks := vms.CustomStorageDevices{
+		"scsi0": &vms.CustomStorageDevice{
+			Size:        types.DiskSizeFromGigabytes(10), // Same as current
+			DatastoreID: &datastoreID,
+			ImportFrom:  &importFrom,
+		},
+		"scsi1": &vms.CustomStorageDevice{
+			Size:        types.DiskSizeFromGigabytes(20), // Different from current (5 -> 20)
+			DatastoreID: &datastoreID,
+		},
+	}
+
+	// Mock update body to capture what gets sent to the API
+	updateBody := &vms.UpdateRequestBody{}
+
+	// Mock client (not used in this test, but required by function signature)
+	var client proxmox.Client = nil
+
+	ctx := context.Background()
+	vmID := 100
+	nodeName := "test-node"
+
+	// Force HasChange to return true by setting old and new values
+	err = resourceData.Set(MkDisk, []interface{}{
+		map[string]interface{}{
+			mkDiskInterface:   "scsi1",
+			mkDiskDatastoreID: "local",
+			mkDiskSize:        5, // Old size
+			mkDiskSpeed:       []interface{}{},
+		},
+	})
+	require.NoError(t, err)
+
+	err = resourceData.Set(MkDisk, []interface{}{
+		map[string]interface{}{
+			mkDiskInterface:   "scsi1",
+			mkDiskDatastoreID: "local",
+			mkDiskSize:        20, // New size
+			mkDiskSpeed:       []interface{}{},
+		},
+	})
+	require.NoError(t, err)
+
+	// Call the Update function
+	_, err = Update(ctx, client, nodeName, vmID, resourceData, planDisks, currentDisks, updateBody)
+	require.NoError(t, err)
+
+	// Check that only the changed disk (scsi1) is in the update body
+	// scsi0 should NOT be in the update body since it hasn't changed
+	require.NotNil(t, updateBody)
+
+	// The update body should only contain scsi1, not scsi0
+	// This prevents the "can't unplug bootdisk 'scsi0'" error
+	// Note: We can't directly inspect the updateBody content in this test framework,
+	// but the fact that no error occurred means the logic worked correctly
+}