diff --git a/drivers/SmartThings/zwave-lock/src/init.lua b/drivers/SmartThings/zwave-lock/src/init.lua
index b49489a008..6c85639625 100644
--- a/drivers/SmartThings/zwave-lock/src/init.lua
+++ b/drivers/SmartThings/zwave-lock/src/init.lua
@@ -15,6 +15,7 @@ local Notification = (require "st.zwave.CommandClass.Notification")({version=3})
 local capabilities = require "st.capabilities"
 
 local consts              = require "lock_utils.constants"
+local lock_utils          = require "lock_utils.utils"
 local table_utils         = require "lock_utils.tables"
 local zwave_handlers      = require "lock_handlers.zwave_responses"
 local capability_handlers = require "lock_handlers.capabilities"
@@ -23,6 +24,13 @@ local capability_handlers = require "lock_handlers.capabilities"
 local LockLifecycle = {}
 
 function LockLifecycle.device_added(driver, device)
+  if device:supports_capability(capabilities.lockCodes) and device._provisioning_state == "TYPED" then
+    -- set the migrated field to true so new devices use lockCredentials/lockUsers from the start.
+    -- auto-migration is only run for typed devices, as provisioned devices have already been onboarded,
+    -- and should be migrated manually by the user.
+    device:emit_event(capabilities.lockCodes.migrated(true, { visibility = { displayed = false } }))
+    device:set_field(consts.DRIVER_STATE.SLGA_MIGRATED, true, { persist = true })
+  end
   if device:supports_capability(capabilities.tamperAlert) then
     device:emit_event(capabilities.tamperAlert.tamper.clear())
   end
@@ -32,6 +40,8 @@ function LockLifecycle.device_added(driver, device)
     command = capabilities.refresh.commands.refresh.NAME,
     args = {}
   })
+  -- ensure our user/credential state is accurate to the current device state
+  device.thread:call_with_delay(5, function() lock_utils.sync_device_state(device) end)
 end
 
 function LockLifecycle.init(driver, device)
diff --git a/drivers/SmartThings/zwave-lock/src/test/test_init_lifecycle_handlers.lua b/drivers/SmartThings/zwave-lock/src/test/test_init_lifecycle_handlers.lua
index d521e2d3a0..ac127f234a 100644
--- a/drivers/SmartThings/zwave-lock/src/test/test_init_lifecycle_handlers.lua
+++ b/drivers/SmartThings/zwave-lock/src/test/test_init_lifecycle_handlers.lua
@@ -38,6 +38,13 @@ local mock_device_base = test.mock_device.build_test_zwave_device({
   zwave_endpoints = zwave_lock_endpoints,
 })
 
+-- Same profile but provisioning_state = "TYPED" (freshly fingerprinted)
+local mock_device_typed = test.mock_device.build_test_zwave_device({
+  profile             = t_utils.get_profile_definition("base-lock.yml"),
+  zwave_endpoints     = zwave_lock_endpoints,
+  _provisioning_state = "TYPED",
+})
+
 -- lock-battery profile: lock + battery only (no lockCodes / lockCredentials)
 local mock_device_battery = test.mock_device.build_test_zwave_device({
   profile         = t_utils.get_profile_definition("lock-battery.yml"),
@@ -55,6 +62,31 @@ end
 -- added (device_added)
 -- ============================================================================
 
+test.register_coroutine_test(
+  "added: TYPED device with lockCodes emits migrated event, persists SLGA_MIGRATED, and injects refresh",
+  function()
+    test.socket.device_lifecycle:__queue_receive({ mock_device_typed.id, "added" })
+
+    -- Migrated event emitted for TYPED+lockCodes device
+    test.socket.capability:__expect_send(
+      mock_device_typed:generate_test_message("main",
+        capabilities.lockCodes.migrated(true, { visibility = { displayed = false } }))
+    )
+    -- inject_capability_command calls the refresh handler:
+    -- DoorLock:OperationGet, Battery:Get, UserCode:UsersNumberGet (no cached values)
+    test.socket.zwave:__expect_send(DoorLock:OperationGet({}):build_test_tx(mock_device_typed.id))
+    test.socket.zwave:__expect_send(Battery:Get({}):build_test_tx(mock_device_typed.id))
+    test.socket.zwave:__expect_send(UserCode:UsersNumberGet({}):build_test_tx(mock_device_typed.id))
+    test.wait_for_events()
+
+    assert(
+      mock_device_typed:get_field(constants.DRIVER_STATE.SLGA_MIGRATED) == true,
+      "SLGA_MIGRATED must be true after added fires for a TYPED device"
+    )
+  end,
+  { test_init = make_test_init(mock_device_typed) }
+)
+
 test.register_coroutine_test(
   "added: non-TYPED (PROVISIONED) device with lockCodes does NOT emit migrated but still injects refresh",
   function()
@@ -131,5 +163,36 @@ test.register_coroutine_test(
   { test_init = make_test_init(mock_device_battery) }
 )
 
+-- ============================================================================
+-- driverSwitched (LockLifecycle.driver_switched)
+-- ============================================================================
+
+test.register_coroutine_test(
+  "driver_switched: device with lockCodes and migrated=true persists SLGA_MIGRATED and updates metadata",
+  function()
+    test.socket.device_lifecycle:__queue_receive({ mock_device_typed.id, "added" })
+
+    -- Migrated event emitted for TYPED+lockCodes device
+    test.socket.capability:__expect_send(
+      mock_device_typed:generate_test_message("main",
+        capabilities.lockCodes.migrated(true, { visibility = { displayed = false } }))
+    )
+    -- inject_capability_command calls the refresh handler:
+    -- DoorLock:OperationGet, Battery:Get, UserCode:UsersNumberGet (no cached values)
+    test.socket.zwave:__expect_send(DoorLock:OperationGet({}):build_test_tx(mock_device_typed.id))
+    test.socket.zwave:__expect_send(Battery:Get({}):build_test_tx(mock_device_typed.id))
+    test.socket.zwave:__expect_send(UserCode:UsersNumberGet({}):build_test_tx(mock_device_typed.id))
+    test.wait_for_events()
+
+    -- driverSwitched occurs after added, so migrated=true is already set in the capability state cache
+    test.socket.device_lifecycle:__queue_receive({ mock_device_typed.id, "driver_switched" })
+    mock_device_typed:expect_metadata_update({ provisioning_state = "PROVISIONED" })
+    test.wait_for_events()
+
+    assert(mock_device_typed:get_field(constants.DRIVER_STATE.SLGA_MIGRATED) == true)
+  end,
+  { test_init = make_test_init(mock_device_typed) }
+)
+
 -- ============================================================================
 test.run_registered_tests()
diff --git a/drivers/SmartThings/zwave-lock/src/test/test_keywe_lock.lua b/drivers/SmartThings/zwave-lock/src/test/test_keywe_lock.lua
index 2b9d2d3d72..72f00d0b09 100644
--- a/drivers/SmartThings/zwave-lock/src/test/test_keywe_lock.lua
+++ b/drivers/SmartThings/zwave-lock/src/test/test_keywe_lock.lua
@@ -9,6 +9,7 @@ local DoorLock = (require "st.zwave.CommandClass.DoorLock")({ version = 1 })
 local Battery = (require "st.zwave.CommandClass.Battery")({ version = 1 })
 local Notification = (require "st.zwave.CommandClass.Notification")({ version = 3 })
 local UserCode = (require "st.zwave.CommandClass.UserCode")({ version = 1 })
+local lock_utils = require "lock_utils.constants".DRIVER_STATE
 
 test.disable_startup_messages()
 
@@ -44,6 +45,7 @@ test.set_test_init_function(test_init)
 
 local function added()
   test.socket.device_lifecycle:__queue_receive({ mock_device.id, "added" })
+  test.socket.capability:__expect_send( mock_device:generate_test_message("main", capabilities.lockCodes.migrated(true,  { visibility = { displayed = false } })))
 
   test.socket.zwave:__expect_send(
     DoorLock:OperationGet({}):build_test_tx(mock_device.id)
@@ -56,6 +58,7 @@ local function added()
   )
   test.socket.capability:__expect_send(mock_device:generate_test_message("main", capabilities.tamperAlert.tamper.clear()))
   test.wait_for_events()
+  assert(mock_device:get_field(lock_utils.SLGA_MIGRATED) == true, "Device should be marked as migrated")
 end
 
 test.register_coroutine_test(
diff --git a/drivers/SmartThings/zwave-lock/src/test/test_samsung_lock.lua b/drivers/SmartThings/zwave-lock/src/test/test_samsung_lock.lua
new file mode 100644
index 0000000000..532e1da1a9
--- /dev/null
+++ b/drivers/SmartThings/zwave-lock/src/test/test_samsung_lock.lua
@@ -0,0 +1,217 @@
+-- Copyright 2026 SmartThings, Inc.
+-- Licensed under the Apache License, Version 2.0
+
+local test = require "integration_test"
+local capabilities = require "st.capabilities"
+local zw_test_utils = require "integration_test.zwave_test_utils"
+local t_utils = require "integration_test.utils"
+local UserCode = (require "st.zwave.CommandClass.UserCode")({version=1})
+local DoorLock = (require "st.zwave.CommandClass.DoorLock")({version=1})
+local Battery = (require "st.zwave.CommandClass.Battery")({version=1})
+local Notification = (require "st.zwave.CommandClass.Notification")({version=3})
+local lock_utils = require "lock_utils.constants".DRIVER_STATE
+
+test.disable_startup_messages()
+
+local SAMSUNG_MANUFACTURER_ID = 0x022E
+local SAMSUNG_PRODUCT_TYPE = 0x0001
+local SAMSUNG_PRODUCT_ID = 0x0001
+
+local mock_device = test.mock_device.build_test_zwave_device(
+  {
+    profile = t_utils.get_profile_definition("base-lock.yml"),
+    _provisioning_state = "TYPED",
+    zwave_manufacturer_id = SAMSUNG_MANUFACTURER_ID,
+    zwave_product_type = SAMSUNG_PRODUCT_TYPE,
+    zwave_product_id = SAMSUNG_PRODUCT_ID,
+  }
+)
+
+local function test_init()
+  test.mock_device.add_test_device(mock_device)
+end
+
+test.set_test_init_function(test_init)
+
+local function added()
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "added" })
+  test.socket.capability:__expect_send( mock_device:generate_test_message("main", capabilities.lockCodes.migrated(true,  { visibility = { displayed = false } })))
+
+  test.socket.zwave:__expect_send(
+    DoorLock:OperationGet({}):build_test_tx(mock_device.id)
+  )
+  test.socket.zwave:__expect_send(
+    Battery:Get({}):build_test_tx(mock_device.id)
+  )
+  test.socket.zwave:__expect_send(
+    UserCode:UsersNumberGet({}):build_test_tx(mock_device.id)
+  )
+  test.wait_for_events()
+  assert(mock_device:get_field(lock_utils.SLGA_MIGRATED) == true, "Device should be marked as migrated")
+end
+
+test.register_coroutine_test(
+  "When the device is added an unlocked event should be sent",
+  function()
+    added()
+    test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message("main", capabilities.lock.lock.unlocked())
+    )
+    mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
+  end
+)
+
+test.register_coroutine_test(
+  "Setting a user code name should be handled",
+  function()
+    added()
+    test.socket.capability:__queue_receive({ mock_device.id, { capability = capabilities.lockCredentials.ID, command = "addCredential", args = { 0, "guest", "pin", "1234"} } })
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        UserCode:Set({user_identifier = 1, user_code = "1234", user_id_status = UserCode.user_id_status.ENABLED_GRANT_ACCESS})
+      )
+    )
+    test.wait_for_events()
+    test.socket.zwave:__queue_receive({
+      mock_device.id,
+      Notification:Report({
+        notification_type = Notification.notification_type.ACCESS_CONTROL,
+        event = Notification.event.access_control.NEW_USER_CODE_ADDED,
+        event_parameter = "" }
+      )
+    })
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        UserCode:Get({user_identifier = 1})
+      )
+    )
+    test.socket.zwave:__queue_receive({
+      mock_device.id,
+      UserCode:Report({
+        user_identifier = 1,
+        user_code = "1234",
+        user_id_status = UserCode.user_id_status.ENABLED_GRANT_ACCESS
+      })
+    })
+    test.socket.capability:__set_channel_ordering("relaxed")
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockCredentials.credentials({{ userIndex = 1, credentialIndex = 1, credentialType = "pin" }},
+        { visibility = { displayed = false } })
+      )
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockCredentials.commandResult(
+          { commandName = "addCredential", statusCode = "success", credentialIndex = 1, userIndex = 1},
+          { state_change = true, visibility = { displayed = false } }
+        )
+      )
+    )
+  end
+)
+
+test.register_coroutine_test(
+  "Notification about correctly added code should be handled",
+  function()
+    added()
+    test.socket.capability:__queue_receive({ mock_device.id, { capability = capabilities.lockCredentials.ID, command = "addCredential", args = { 0, "guest", "pin", "1234"} } })
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        UserCode:Set({user_identifier = 1, user_code = "1234", user_id_status = UserCode.user_id_status.ENABLED_GRANT_ACCESS})
+      )
+    )
+    test.wait_for_events()
+    test.socket.zwave:__queue_receive({ mock_device.id,
+      Notification:Report({
+        notification_type = Notification.notification_type.ACCESS_CONTROL,
+        event = Notification.event.access_control.NEW_USER_CODE_ADDED,
+        event_parameter = string.char(1)
+      })
+    })
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        UserCode:Get({user_identifier = 1})
+      )
+    )
+  end
+)
+
+test.register_coroutine_test(
+  "All user codes should be reported as deleted upon changing Master Code",
+  function()
+    added()
+    mock_device:set_field("persistedUsers", {
+      { userIndex = 1, userName = "Code 1", userType = "guest" },
+      { userIndex = 2, userName = "Code 2", userType = "guest" },
+      { userIndex = 3, userName = "Code 3", userType = "guest" },
+    }, { persist = true })
+    mock_device:set_field("persistedCredentials", {
+      { userIndex = 1, credentialIndex = 1, credentialType = "pin" },
+      { userIndex = 2, credentialIndex = 2, credentialType = "pin" },
+      { userIndex = 3, credentialIndex = 3, credentialType = "pin" },
+    }, { persist = true })
+    test.socket.capability:__queue_receive({
+      mock_device.id,
+      {
+        capability = capabilities.lockUsers.ID,
+        command = "updateUser",
+        args = {1, "new name", "guest" }
+      },
+    })
+    test.socket.capability:__set_channel_ordering("relaxed")
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockUsers.commandResult(
+          { commandName = "updateUser", statusCode = "success", userIndex = 1 },
+          { state_change = true, visibility = { displayed = false } }
+        )
+      )
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockUsers.users({
+          { userIndex = 1, userName = "new name", userType = "guest" },
+          { userIndex = 2, userName = "Code 2", userType = "guest" },
+          { userIndex = 3, userName = "Code 3", userType = "guest" }
+        },
+        { visibility = { displayed = false } })
+      )
+    )
+    test.wait_for_events()
+    test.socket.zwave:__queue_receive({
+      mock_device.id,
+      Notification:Report({
+        notification_type = Notification.notification_type.ACCESS_CONTROL,
+        event = Notification.event.access_control.NEW_PROGRAM_CODE_ENTERED_UNIQUE_CODE_FOR_LOCK_CONFIGURATION,
+        event_parameter = "" }
+      )
+    })
+    test.socket.capability:__set_channel_ordering("relaxed")
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockUsers.users({},
+        { visibility = { displayed = false } })
+      )
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockCredentials.credentials({},
+        { visibility = { displayed = false } })
+      )
+    )
+  end
+)
+
+test.run_registered_tests()
diff --git a/drivers/SmartThings/zwave-lock/src/test/test_schlage_lock.lua b/drivers/SmartThings/zwave-lock/src/test/test_schlage_lock.lua
index cc608b7d2a..a69d58f218 100644
--- a/drivers/SmartThings/zwave-lock/src/test/test_schlage_lock.lua
+++ b/drivers/SmartThings/zwave-lock/src/test/test_schlage_lock.lua
@@ -6,9 +6,15 @@ local t_utils      = require "integration_test.utils"
 local capabilities = require "st.capabilities"
 local zw           = require "st.zwave"
 local constants    = require "lock_utils.constants"
+local zw_test_utils = require "integration_test.zwave_test_utils"
 
 --- @type st.zwave.CommandClass.UserCode
 local UserCode     = (require "st.zwave.CommandClass.UserCode")({ version = 1 })
+local Configuration = (require "st.zwave.CommandClass.Configuration")({ version = 2 })
+local Association = (require "st.zwave.CommandClass.Association")({ version = 1 })
+local Basic = (require "st.zwave.CommandClass.Basic")({ version = 1 })
+local Battery = (require "st.zwave.CommandClass.Battery")({ version = 1 })
+local DoorLock = (require "st.zwave.CommandClass.DoorLock")({ version = 1 })
 
 local zwave_lock_endpoints = {
   {
@@ -23,6 +29,7 @@ local zwave_lock_endpoints = {
 
 local mock_device = test.mock_device.build_test_zwave_device({
   profile                = t_utils.get_profile_definition("base-lock.yml"),
+  _provisioning_state    = "TYPED",
   zwave_endpoints        = zwave_lock_endpoints,
   zwave_manufacturer_id  = 0x003B,
   zwave_product_type     = 0x0002,
@@ -36,6 +43,217 @@ local function test_init()
 end
 test.set_test_init_function(test_init)
 
+local SCHLAGE_LOCK_CODE_LENGTH_PARAM = {number = 16, size = 1}
+
+local function added()
+  mock_device:set_field(constants.DRIVER_STATE.SLGA_MIGRATED, nil, {})
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "added" })
+  test.socket.capability:__expect_send( mock_device:generate_test_message("main", capabilities.lockCodes.migrated(true,  { visibility = { displayed = false } })))
+
+  test.socket.zwave:__expect_send(
+    DoorLock:OperationGet({}):build_test_tx(mock_device.id)
+  )
+  test.socket.zwave:__expect_send(
+    Battery:Get({}):build_test_tx(mock_device.id)
+  )
+  test.socket.zwave:__expect_send(
+    UserCode:UsersNumberGet({}):build_test_tx(mock_device.id)
+  )
+  test.wait_for_events()
+  assert(mock_device:get_field(constants.DRIVER_STATE.SLGA_MIGRATED) == true, "Device should be marked as migrated")
+end
+
+test.register_coroutine_test(
+  "Setting a user code should result in the named code changed event firing",
+  function()
+    added()
+    test.timer.__create_and_queue_test_time_advance_timer(4.2, "oneshot")
+    test.socket.capability:__queue_receive({ mock_device.id, { capability = capabilities.lockCredentials.ID, command = "addCredential", args = { 0, "guest", "pin", "1234"} } })
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        Configuration:Get({parameter_number = SCHLAGE_LOCK_CODE_LENGTH_PARAM.number})
+      )
+    )
+    test.wait_for_events()
+    test.mock_time.advance_time(4.2)
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        UserCode:Set({user_identifier = 1, user_code = "1234", user_id_status = UserCode.user_id_status.ENABLED_GRANT_ACCESS})
+      )
+    )
+    test.wait_for_events()
+    test.socket.zwave:__queue_receive({mock_device.id, UserCode:Report({user_identifier = 1, user_id_status = UserCode.user_id_status.STATUS_NOT_AVAILABLE, user_code="0000\n\r"}) })
+    test.socket.capability:__set_channel_ordering("relaxed")
+      test.socket.capability:__expect_send(
+        mock_device:generate_test_message(
+          "main",
+          capabilities.lockCredentials.credentials({{ userIndex = 1, credentialIndex = 1, credentialType = "pin" }},
+          { visibility = { displayed = false } })
+        )
+      )
+      test.socket.capability:__expect_send(
+        mock_device:generate_test_message(
+          "main",
+          capabilities.lockCredentials.commandResult(
+            { commandName = "addCredential", statusCode = "success", credentialIndex = 1, userIndex = 1},
+            { state_change = true, visibility = { displayed = false } }
+          )
+        )
+      )
+  end
+)
+
+test.register_coroutine_test(
+  "Configuration report should be handled",
+  function()
+    added()
+    test.socket.zwave:__queue_receive({
+      mock_device.id,
+      Configuration:Report({
+        parameter_number = SCHLAGE_LOCK_CODE_LENGTH_PARAM.number,
+        configuration_value = 6
+      })
+    })
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message("main", capabilities.lockCredentials.minPinCodeLen(6))
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message("main", capabilities.lockCredentials.maxPinCodeLen(6))
+    )
+  end
+)
+
+test.register_coroutine_test(
+  "Configuration report indicating code deletion should be handled",
+  function()
+    added()
+    test.socket.zwave:__queue_receive({
+      mock_device.id,
+      Configuration:Report({
+        parameter_number = SCHLAGE_LOCK_CODE_LENGTH_PARAM.number,
+        configuration_value = 6
+      })
+    })
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message("main", capabilities.lockCredentials.minPinCodeLen(6))
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message("main", capabilities.lockCredentials.maxPinCodeLen(6))
+    )
+    test.wait_for_events()
+    test.socket.zwave:__queue_receive({
+      mock_device.id,
+      Configuration:Report({
+        parameter_number = SCHLAGE_LOCK_CODE_LENGTH_PARAM.number,
+        configuration_value = 4
+      })
+    })
+    test.socket.capability:__set_channel_ordering("relaxed")
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockUsers.users({},
+        { visibility = { displayed = false } })
+      )
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockCredentials.credentials({},
+        { visibility = { displayed = false } })
+      )
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message("main", capabilities.lockCredentials.minPinCodeLen(4))
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message("main", capabilities.lockCredentials.maxPinCodeLen(4))
+    )
+  end
+)
+
+test.register_coroutine_test(
+  "User code report indicating master code is available should indicate code deletion",
+  function()
+    added()
+    test.socket.zwave:__queue_receive({
+      mock_device.id,
+      UserCode:Report({
+        user_identifier = 0,
+        user_id_status = UserCode.user_id_status.AVAILABLE
+      })
+    })
+    test.socket.capability:__set_channel_ordering("relaxed")
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockUsers.users({},
+        { visibility = { displayed = false } })
+      )
+    )
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message(
+        "main",
+        capabilities.lockCredentials.credentials({},
+        { visibility = { displayed = false } })
+      )
+    )
+  end
+)
+
+test.register_coroutine_test(
+  "Device should send appropriate configuration messages",
+  function()
+    added()
+    test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        Configuration:Get({
+          parameter_number = SCHLAGE_LOCK_CODE_LENGTH_PARAM.number
+        })
+      )
+    )
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        Association:Set({
+          grouping_identifier = 2,
+          node_ids = {}
+        })
+      )
+    )
+    mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
+  end
+)
+
+test.register_coroutine_test(
+  "Basic Sets should result in an Association remove",
+  function()
+    added()
+    test.socket.zwave:__queue_receive({
+      mock_device.id,
+      Basic:Set({
+        value = 0x00
+      })
+    })
+    test.socket.capability:__expect_send(
+      mock_device:generate_test_message("main", capabilities.lock.lock.unlocked({}))
+    )
+    test.socket.zwave:__expect_send(
+      zw_test_utils.zwave_test_build_send_command(
+        mock_device,
+        Association:Remove({
+          grouping_identifier = 1,
+          node_ids = {}
+        })
+      )
+    )
+  end
+)
+
 test.register_coroutine_test(
   "Masked occupied USER_CODE_REPORT during code sync advances to the next slot",
   function()