58 Unit test fixes for matter test cases

This change covers the matter test case updates associated with #2310.

Author: nickolas-deboom

drivers/SmartThings/matter-lock/src/test/test_aqara_matter_lock.lua

@@ -41,7 +41,8 @@ local mock_device = test.mock_device.build_test_matter_device({
           cluster_id = clusters.DoorLock.ID,
           cluster_type = "SERVER",
           cluster_revision = 1,
-          feature_map = 0x0001, --u32 bitmap
+          feature_map = clusters.DoorLock.types.Feature.PIN_CREDENTIAL |
+            clusters.DoorLock.types.Feature.USER
         }
       },
       device_types = {
@@ -52,6 +53,13 @@ local mock_device = test.mock_device.build_test_matter_device({
 })
 
 local function test_init()
+  test.disable_startup_messages()
+  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "added" })
+  test.socket.capability:__expect_send(
+    mock_device:generate_test_message("main", capabilities.lockAlarm.alarm.clear({state_change = true}))
+  )
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "init" })
   local subscribe_request = clusters.DoorLock.attributes.LockState:subscribe(mock_device)
   subscribe_request:merge(clusters.DoorLock.attributes.OperatingMode:subscribe(mock_device))
   subscribe_request:merge(clusters.DoorLock.attributes.NumberOfTotalUsersSupported:subscribe(mock_device))
@@ -63,7 +71,12 @@ local function test_init()
   subscribe_request:merge(clusters.DoorLock.events.DoorLockAlarm:subscribe(mock_device))
   subscribe_request:merge(clusters.DoorLock.events.LockUserChange:subscribe(mock_device))
   test.socket["matter"]:__expect_send({mock_device.id, subscribe_request})
-  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+  test.socket.capability:__expect_send(
+    mock_device:generate_test_message("main", capabilities.lock.supportedLockCommands({"lock", "unlock"}, {visibility = {displayed = false}}))
+  )
+  mock_device:expect_metadata_update({ profile = "lock-user-pin" })
+  mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 end
 
 test.set_test_init_function(test_init)

drivers/SmartThings/matter-lock/src/test/test_bridged_matter_lock.lua

@@ -15,6 +15,7 @@
 local test = require "integration_test"
 test.add_package_capability("lockAlarm.yml")
 local t_utils = require "integration_test.utils"
+local capabilities = require "st.capabilities"
 local clusters = require "st.matter.clusters"
 
 local mock_device_record = {
@@ -41,58 +42,75 @@ local mock_device_record = {
 local mock_device = test.mock_device.build_test_matter_device(mock_device_record)
 
 local mock_device_record_level = {
-    profile = t_utils.get_profile_definition("lock-nocodes-notamper-batteryLevel.yml"),
-    manufacturer_info = {vendor_id = 0x129F, product_id = 0x0001}, -- Level Lock Plus
-    endpoints = {
-      {
-        endpoint_id = 2,
-        clusters = {
-          {cluster_id = clusters.Basic.ID, cluster_type = "SERVER"},
-        },
-        device_types = {
-          device_type_id = 0x0016, device_type_revision = 1, -- RootNode
-        }
+  profile = t_utils.get_profile_definition("lock-nocodes-notamper-batteryLevel.yml"),
+  manufacturer_info = {vendor_id = 0x129F, product_id = 0x0001}, -- Level Lock Plus
+  endpoints = {
+    {
+      endpoint_id = 2,
+      clusters = {
+        {cluster_id = clusters.Basic.ID, cluster_type = "SERVER"},
       },
-      {
-        endpoint_id = 10,
-        clusters = {
-          {cluster_id = clusters.DoorLock.ID, cluster_type = "SERVER", feature_map = 0x0000},
-        },
+      device_types = {
+        device_type_id = 0x0016, device_type_revision = 1, -- RootNode
+      }
+    },
+    {
+      endpoint_id = 10,
+      clusters = {
+        {cluster_id = clusters.DoorLock.ID, cluster_type = "SERVER", feature_map = 0x0000},
       },
     },
+  },
 }
 
 local mock_device_level = test.mock_device.build_test_matter_device(mock_device_record_level)
 
 local function test_init()
-    local subscribe_request = clusters.DoorLock.attributes.LockState:subscribe(mock_device)
-    subscribe_request:merge(clusters.DoorLock.events.DoorLockAlarm:subscribe(mock_device))
-    subscribe_request:merge(clusters.DoorLock.events.LockOperation:subscribe(mock_device))
-    subscribe_request:merge(clusters.DoorLock.events.LockUserChange:subscribe(mock_device))
-    test.socket["matter"]:__expect_send({mock_device.id, subscribe_request})
-    test.mock_device.add_test_device(mock_device)
+  test.disable_startup_messages()
+  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "added" })
+  test.socket.capability:__expect_send(
+    mock_device:generate_test_message("main", capabilities.tamperAlert.tamper.clear())
+  )
+  test.socket.capability:__expect_send(
+    mock_device:generate_test_message("main", capabilities.lockCodes.lockCodes("[]", {visibility = {displayed = false}}))
+  )
+  local req = clusters.DoorLock.attributes.MaxPINCodeLength:read(mock_device, 10)
+  req:merge(clusters.DoorLock.attributes.MinPINCodeLength:read(mock_device, 10))
+  req:merge(clusters.DoorLock.attributes.NumberOfPINUsersSupported:read(mock_device, 10))
+  test.socket.matter:__expect_send({mock_device.id, req})
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "init" })
+  local subscribe_request = clusters.DoorLock.attributes.LockState:subscribe(mock_device)
+  subscribe_request:merge(clusters.DoorLock.events.DoorLockAlarm:subscribe(mock_device))
+  subscribe_request:merge(clusters.DoorLock.events.LockOperation:subscribe(mock_device))
+  subscribe_request:merge(clusters.DoorLock.events.LockUserChange:subscribe(mock_device))
+  test.socket["matter"]:__expect_send({mock_device.id, subscribe_request})
+  test.mock_device.add_test_device(mock_device)
+
 
-    local subscribe_request_level = clusters.DoorLock.attributes.LockState:subscribe(mock_device_level)
-    test.socket["matter"]:__expect_send({mock_device_level.id, subscribe_request_level})
-    test.mock_device.add_test_device(mock_device_level)
+  test.mock_device.add_test_device(mock_device_level)
+  test.socket.device_lifecycle:__queue_receive({ mock_device_level.id, "added" })
+  test.socket.device_lifecycle:__queue_receive({ mock_device_level.id, "init" })
+  local subscribe_request_level = clusters.DoorLock.attributes.LockState:subscribe(mock_device_level)
+  test.socket["matter"]:__expect_send({mock_device_level.id, subscribe_request_level})
 end
 test.set_test_init_function(test_init)
 
 test.register_coroutine_test(
-    "doConfigure lifecycle event for base-lock-nobattery",
-    function()
-        test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
-        mock_device:expect_metadata_update({ profile = "base-lock-nobattery" })
-        mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
-    end
+  "doConfigure lifecycle event for base-lock-nobattery",
+  function()
+    test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+    mock_device:expect_metadata_update({ profile = "base-lock-nobattery" })
+    mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
+  end
 )
 
 test.register_coroutine_test(
-    "doConfigure lifecycle event for Level Lock Plus profile",
-    function()
-        test.socket.device_lifecycle:__queue_receive({ mock_device_level.id, "doConfigure" })
-        mock_device_level:expect_metadata_update({ provisioning_state = "PROVISIONED" })
-    end
+  "doConfigure lifecycle event for Level Lock Plus profile",
+  function()
+    test.socket.device_lifecycle:__queue_receive({ mock_device_level.id, "doConfigure" })
+    mock_device_level:expect_metadata_update({ provisioning_state = "PROVISIONED" })
+  end
 )
 
 test.run_registered_tests()

drivers/SmartThings/matter-lock/src/test/test_matter_lock.lua

@@ -43,12 +43,21 @@ local mock_device_record = {
 local mock_device = test.mock_device.build_test_matter_device(mock_device_record)
 
 local function test_init()
+  test.disable_startup_messages()
+  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "added" })
+  test.socket.capability:__expect_send(
+    mock_device:generate_test_message("main", capabilities.tamperAlert.tamper.clear())
+  )
+  mock_device:expect_metadata_update({ profile = "lock-without-codes" })
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "init" })
   local subscribe_request = clusters.DoorLock.attributes.LockState:subscribe(mock_device)
   subscribe_request:merge(clusters.PowerSource.attributes.BatPercentRemaining:subscribe(mock_device))
   subscribe_request:merge(clusters.DoorLock.events.DoorLockAlarm:subscribe(mock_device))
   subscribe_request:merge(clusters.DoorLock.events.LockOperation:subscribe(mock_device))
   test.socket["matter"]:__expect_send({mock_device.id, subscribe_request})
-  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+  mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 end
 
 test.set_test_init_function(test_init)

drivers/SmartThings/matter-lock/src/test/test_matter_lock_battery.lua

@@ -15,6 +15,7 @@
 local test = require "integration_test"
 test.add_package_capability("lockAlarm.yml")
 local t_utils = require "integration_test.utils"
+local capabilities = require "st.capabilities"
 local clusters = require "st.matter.clusters"
 local uint32 = require "st.matter.data_types.Uint32"
 
@@ -67,28 +68,41 @@ local mock_device_no_battery_record = {
 local mock_device_no_battery = test.mock_device.build_test_matter_device(mock_device_no_battery_record)
 
 local function test_init()
+  test.disable_startup_messages()
+  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "added" })
+  test.socket.capability:__expect_send(
+    mock_device:generate_test_message("main", capabilities.tamperAlert.tamper.clear())
+  )
+  mock_device:expect_metadata_update({ profile = "lock-without-codes" })
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "init" })
   local subscribe_request = clusters.DoorLock.attributes.LockState:subscribe(mock_device)
   subscribe_request:merge(clusters.PowerSource.attributes.BatPercentRemaining:subscribe(mock_device))
   subscribe_request:merge(clusters.DoorLock.events.DoorLockAlarm:subscribe(mock_device))
   subscribe_request:merge(clusters.DoorLock.events.LockOperation:subscribe(mock_device))
   subscribe_request:merge(clusters.DoorLock.events.LockUserChange:subscribe(mock_device))
   test.socket["matter"]:__expect_send({mock_device.id, subscribe_request})
-  test.mock_device.add_test_device(mock_device)
   test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
   mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
-  local read_attribute_list = clusters.PowerSource.attributes.AttributeList:read()
-  test.socket.matter:__expect_send({mock_device.id, read_attribute_list})
+  test.socket.matter:__expect_send({mock_device.id, clusters.PowerSource.attributes.AttributeList:read()})
 end
 test.set_test_init_function(test_init)
 
 local function test_init_no_battery()
+  test.disable_startup_messages()
+  test.mock_device.add_test_device(mock_device_no_battery)
+  test.socket.device_lifecycle:__queue_receive({ mock_device_no_battery.id, "added" })
+  test.socket.capability:__expect_send(
+    mock_device_no_battery:generate_test_message("main", capabilities.tamperAlert.tamper.clear())
+  )
+  mock_device_no_battery:expect_metadata_update({ profile = "lock-without-codes-nobattery" })
+  test.socket.device_lifecycle:__queue_receive({ mock_device_no_battery.id, "init" })
   local subscribe_request = clusters.DoorLock.attributes.LockState:subscribe(mock_device_no_battery)
-  subscribe_request:merge(clusters.PowerSource.attributes.BatPercentRemaining:subscribe(mock_device))
+  subscribe_request:merge(clusters.PowerSource.attributes.BatPercentRemaining:subscribe(mock_device_no_battery))
   subscribe_request:merge(clusters.DoorLock.events.DoorLockAlarm:subscribe(mock_device_no_battery))
   subscribe_request:merge(clusters.DoorLock.events.LockOperation:subscribe(mock_device_no_battery))
   subscribe_request:merge(clusters.DoorLock.events.LockUserChange:subscribe(mock_device_no_battery))
   test.socket["matter"]:__expect_send({mock_device_no_battery.id, subscribe_request})
-  test.mock_device.add_test_device(mock_device_no_battery)
   test.socket.device_lifecycle:__queue_receive({ mock_device_no_battery.id, "doConfigure" })
   mock_device_no_battery:expect_metadata_update({ profile = "base-lock-nobattery" })
   mock_device_no_battery:expect_metadata_update({ provisioning_state = "PROVISIONED" })

drivers/SmartThings/matter-lock/src/test/test_matter_lock_batteryLevel.lua

@@ -44,10 +44,15 @@ local mock_device = test.mock_device.build_test_matter_device(mock_device_record
 
 
 local function test_init()
-    local subscribe_request = clusters.DoorLock.attributes.LockState:subscribe(mock_device)
-    subscribe_request:merge(clusters.PowerSource.attributes.BatChargeLevel:subscribe(mock_device))
-    test.socket["matter"]:__expect_send({mock_device.id, subscribe_request})
-    test.mock_device.add_test_device(mock_device)
+  test.disable_startup_messages()
+  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "added" })
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "init" })
+  local subscribe_request = clusters.DoorLock.attributes.LockState:subscribe(mock_device)
+  subscribe_request:merge(clusters.PowerSource.attributes.BatChargeLevel:subscribe(mock_device))
+  test.socket["matter"]:__expect_send({mock_device.id, subscribe_request})
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+  mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 end
 test.set_test_init_function(test_init)
 
@@ -84,20 +89,20 @@ test.register_message_test(
       message = mock_device:generate_test_message("main", capabilities.batteryLevel.battery.warning()),
     },
     {
-        channel = "matter",
-        direction = "receive",
-        message = {
-          mock_device.id,
-          clusters.PowerSource.attributes.BatChargeLevel:build_test_report_data(
-            mock_device, 10, clusters.PowerSource.types.BatChargeLevelEnum.OK
-          ),
-        },
-      },
-      {
-        channel = "capability",
-        direction = "send",
-        message = mock_device:generate_test_message("main", capabilities.batteryLevel.battery.normal()),
+      channel = "matter",
+      direction = "receive",
+      message = {
+        mock_device.id,
+        clusters.PowerSource.attributes.BatChargeLevel:build_test_report_data(
+          mock_device, 10, clusters.PowerSource.types.BatChargeLevelEnum.OK
+        ),
       },
+    },
+    {
+      channel = "capability",
+      direction = "send",
+      message = mock_device:generate_test_message("main", capabilities.batteryLevel.battery.normal()),
+    },
   }
 )
 

drivers/SmartThings/matter-lock/src/test/test_matter_lock_codes.lua

@@ -12,20 +12,6 @@
 -- See the License for the specific language governing permissions and
 -- limitations under the License.
 
--- Copyright 2022 SmartThings
---
--- Licensed under the Apache License, Version 2.0 (the "License");
--- you may not use this file except in compliance with the License.
--- You may obtain a copy of the License at
---
---     http://www.apache.org/licenses/LICENSE-2.0
---
--- Unless required by applicable law or agreed to in writing, software
--- distributed under the License is distributed on an "AS IS" BASIS,
--- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
--- See the License for the specific language governing permissions and
--- limitations under the License.
--- Mock out globals
 local test = require "integration_test"
 local capabilities = require "st.capabilities"
 test.add_package_capability("lockAlarm.yml")
@@ -35,6 +21,7 @@ local clusters = require "st.matter.clusters"
 local DoorLock = clusters.DoorLock
 local im = require "st.matter.interaction_model"
 local types = DoorLock.types
+
 local mock_device_record = {
   profile = t_utils.get_profile_definition("base-lock.yml"),
   manufacturer_info = {vendor_id = 0xcccc, product_id = 0x1},
@@ -56,21 +43,26 @@ local mock_device_record = {
           cluster_type = "SERVER",
           feature_map = 0x0101, -- PIN & USR
         },
-        {cluster_id = clusters.PowerSource.ID, cluster_type = "SERVER"},
+        {cluster_id = clusters.PowerSource.ID, cluster_type = "SERVER", feature_map = 0},
       },
     },
   },
 }
 local mock_device = test.mock_device.build_test_matter_device(mock_device_record)
 
 local function test_init()
+  test.disable_startup_messages()
+  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "init" })
   local subscribe_request = DoorLock.attributes.LockState:subscribe(mock_device)
   subscribe_request:merge(clusters.PowerSource.attributes.BatPercentRemaining:subscribe(mock_device))
   subscribe_request:merge(DoorLock.events.LockUserChange:subscribe(mock_device))
   subscribe_request:merge(DoorLock.events.LockOperation:subscribe(mock_device))
   subscribe_request:merge(DoorLock.events.DoorLockAlarm:subscribe(mock_device))
   test.socket["matter"]:__expect_send({mock_device.id, subscribe_request})
-  test.mock_device.add_test_device(mock_device)
+  test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+  mock_device:expect_metadata_update({ profile = "base-lock-nobattery" })
+  mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 end
 
 test.set_test_init_function(test_init)
@@ -189,11 +181,11 @@ local function init_code_slot(slot_number, name, device)
   )
 
   local credential = DoorLock.types.DlCredential(
-                       {
+    {
       credential_type = DoorLock.types.DlCredentialType.PIN,
       credential_index = slot_number,
     }
-                     )
+  )
   test.socket.matter:__expect_send(
     {
       device.id,