wyzeapy 0.5.28__py3-none-any.whl → 0.5.30__py3-none-any.whl

wyzeapy/tests/test_bulb_service.py

@@ -1,135 +0,0 @@
-import unittest
-from unittest.mock import AsyncMock, MagicMock
-from wyzeapy.services.bulb_service import BulbService, Bulb
-from wyzeapy.types import DeviceTypes, PropertyIDs
-
-
-class TestBulbService(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        mock_auth_lib = MagicMock()
-        self.bulb_service = BulbService(auth_lib=mock_auth_lib)
-        self.bulb_service._get_property_list = AsyncMock()
-        self.bulb_service.get_updated_params = AsyncMock()
-
-    async def test_update_bulb_basic_properties(self):
-        mock_bulb = Bulb({
-            "device_type": "Light",
-            "product_model": "WLPA19",
-            "mac": "TEST123",
-            "raw_dict": {},
-            "device_params": {"ip": "192.168.1.100"},
-            "prop_map": {},
-            'product_type': DeviceTypes.MESH_LIGHT.value
-        })
-
-        # Mock the property list response
-        self.bulb_service._get_property_list.return_value = [
-            (PropertyIDs.BRIGHTNESS, "75"),
-            (PropertyIDs.COLOR_TEMP, "4000"),
-            (PropertyIDs.ON, "1"),
-            (PropertyIDs.AVAILABLE, "1")
-        ]
-
-        updated_bulb = await self.bulb_service.update(mock_bulb)
-
-        self.assertEqual(updated_bulb.brightness, 75)
-        self.assertEqual(updated_bulb.color_temp, 4000)
-        self.assertTrue(updated_bulb.on)
-        self.assertTrue(updated_bulb.available)
-
-    async def test_update_bulb_lightstrip_properties(self):
-        mock_bulb = Bulb({
-            "device_type": "Light",
-            "product_model": "WLST19",
-            "mac": "TEST456",
-            "raw_dict": {},
-            "device_params": {"ip": "192.168.1.101"},
-            "prop_map": {},
-            'product_type': DeviceTypes.LIGHTSTRIP.value
-        })
-        mock_bulb.product_type = DeviceTypes.LIGHTSTRIP
-
-        # Mock the property list response with the corrected color format (no # symbol)
-        self.bulb_service._get_property_list.return_value = [
-            (PropertyIDs.COLOR, "FF0000"),  # Removed the # symbol
-            (PropertyIDs.COLOR_MODE, "1"),
-            (PropertyIDs.LIGHTSTRIP_EFFECTS, "rainbow"),
-            (PropertyIDs.LIGHTSTRIP_MUSIC_MODE, "1"),
-            (PropertyIDs.ON, "1"),
-            (PropertyIDs.AVAILABLE, "1")
-        ]
-
-        updated_bulb = await self.bulb_service.update(mock_bulb)
-
-        self.assertEqual(updated_bulb.color, "FF0000")
-        self.assertEqual(updated_bulb.color_mode, "1")
-        self.assertEqual(updated_bulb.effects, "rainbow")
-        self.assertTrue(updated_bulb.music_mode)
-        self.assertTrue(updated_bulb.on)
-        self.assertTrue(updated_bulb.available)
-
-    async def test_update_bulb_sun_match(self):
-        mock_bulb = Bulb({
-            "device_type": "Light",
-            "product_model": "WLPA19",
-            "mac": "TEST789",
-            "raw_dict": {},
-            "device_params": {"ip": "192.168.1.102"},
-            "prop_map": {},
-            'product_type': DeviceTypes.MESH_LIGHT.value
-        })
-
-        # Mock the property list response
-        self.bulb_service._get_property_list.return_value = [
-            (PropertyIDs.SUN_MATCH, "1"),
-            (PropertyIDs.ON, "1"),
-            (PropertyIDs.AVAILABLE, "1")
-        ]
-
-        updated_bulb = await self.bulb_service.update(mock_bulb)
-
-        self.assertTrue(updated_bulb.sun_match)
-        self.assertTrue(updated_bulb.on)
-        self.assertTrue(updated_bulb.available)
-
-    async def test_update_bulb_invalid_color_temp(self):
-        mock_bulb = Bulb({
-            "device_type": "Light",
-            "product_model": "WLPA19",
-            "mac": "TEST101",
-            "raw_dict": {},
-            "device_params": {"ip": "192.168.1.103"},
-            "prop_map": {},
-            'product_type': DeviceTypes.MESH_LIGHT.value
-        })
-
-        # Mock the property list response with invalid color temp
-        self.bulb_service._get_property_list.return_value = [
-            (PropertyIDs.COLOR_TEMP, "invalid"),
-            (PropertyIDs.ON, "1")
-        ]
-
-        updated_bulb = await self.bulb_service.update(mock_bulb)
-
-        # Should default to 2700K when invalid
-        self.assertEqual(updated_bulb.color_temp, 2700)
-        self.assertTrue(updated_bulb.on)
-
-    async def test_get_bulbs(self):
-        mock_device = MagicMock()
-        mock_device.type = DeviceTypes.LIGHT
-        mock_device.raw_dict = {
-            "device_type": "Light",
-            "product_model": "WLPA19",
-            "device_params": {"ip": "192.168.1.104"},
-            "prop_map": {},
-            'product_type': DeviceTypes.MESH_LIGHT.value
-        }
-
-        self.bulb_service.get_object_list = AsyncMock(return_value=[mock_device])
-
-        bulbs = await self.bulb_service.get_bulbs()
-
-        self.assertEqual(len(bulbs), 1)
-        self.assertIsInstance(bulbs[0], Bulb)
-        self.bulb_service.get_object_list.assert_awaited_once()

wyzeapy/tests/test_camera_service.py

@@ -1,180 +0,0 @@
-import unittest
-from unittest.mock import AsyncMock, MagicMock
-from wyzeapy.services.camera_service import CameraService, Camera, DEVICEMGMT_API_MODELS
-from wyzeapy.types import DeviceTypes, PropertyIDs, Event
-from wyzeapy.wyze_auth_lib import WyzeAuthLib
-
-
-class TestCameraService(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
-        self.camera_service = CameraService(auth_lib=self.mock_auth_lib)
-        self.camera_service._get_property_list = AsyncMock()
-        self.camera_service._get_event_list = AsyncMock()
-        self.camera_service._run_action = AsyncMock()
-        self.camera_service._run_action_devicemgmt = AsyncMock()
-        self.camera_service._set_property = AsyncMock()
-        self.camera_service._set_property_list = AsyncMock()
-        self.camera_service._set_toggle = AsyncMock()
-        self.camera_service.get_updated_params = AsyncMock()
-
-        # Create a test camera
-        self.test_camera = Camera({
-            "device_type": DeviceTypes.CAMERA.value,
-            "product_model": "WYZEC1",
-            "mac": "TEST123",
-            "nickname": "Test Camera",
-            "device_params": {"ip": "192.168.1.100"},
-            "raw_dict": {}
-        })
-
-    async def test_update_legacy_camera(self):
-        # Mock responses
-        self.camera_service._get_event_list.return_value = {
-            'data': {
-                'event_list': [{
-                    'event_ts': 1234567890,
-                    'device_mac': 'TEST123',
-                    'event_type': 'motion'
-                }]
-            }
-        }
-        
-        self.camera_service._get_property_list.return_value = [
-            (PropertyIDs.AVAILABLE, "1"),
-            (PropertyIDs.ON, "1"),
-            (PropertyIDs.CAMERA_SIREN, "0"),
-            (PropertyIDs.ACCESSORY, "0"),
-            (PropertyIDs.NOTIFICATION, "1"),
-            (PropertyIDs.MOTION_DETECTION, "1")
-        ]
-
-        updated_camera = await self.camera_service.update(self.test_camera)
-
-        self.assertTrue(updated_camera.available)
-        self.assertTrue(updated_camera.on)
-        self.assertFalse(updated_camera.siren)
-        self.assertFalse(updated_camera.floodlight)
-        self.assertTrue(updated_camera.notify)
-        self.assertTrue(updated_camera.motion)
-        self.assertIsNotNone(updated_camera.last_event)
-        self.assertEqual(updated_camera.last_event_ts, 1234567890)
-
-    async def test_update_devicemgmt_camera(self):
-        # Create a test camera using new API model
-        devicemgmt_camera = Camera({
-            "device_type": DeviceTypes.CAMERA.value,
-            "product_model": "LD_CFP",  # Floodlight pro model
-            "mac": "TEST456",
-            "nickname": "Test DeviceMgmt Camera",
-            "device_params": {"ip": "192.168.1.101"},
-            "raw_dict": {}
-        })
-
-        self.camera_service._get_iot_prop_devicemgmt = AsyncMock(return_value={
-            'data': {
-                'capabilities': [
-                    {
-                        'name': 'camera',
-                        'properties': {'motion-detect-recording': True}
-                    },
-                    {
-                        'name': 'floodlight',
-                        'properties': {'on': True}
-                    },
-                    {
-                        'name': 'siren',
-                        'properties': {'state': True}
-                    },
-                    {
-                        'name': 'iot-device',
-                        'properties': {
-                            'push-switch': True,
-                            'iot-power': True,
-                            'iot-state': True
-                        }
-                    }
-                ]
-            }
-        })
-
-        updated_camera = await self.camera_service.update(devicemgmt_camera)
-
-        self.assertTrue(updated_camera.available)
-        self.assertTrue(updated_camera.on)
-        self.assertTrue(updated_camera.siren)
-        self.assertTrue(updated_camera.floodlight)
-        self.assertTrue(updated_camera.notify)
-        self.assertTrue(updated_camera.motion)
-
-    async def test_turn_on_off_legacy_camera(self):
-        await self.camera_service.turn_on(self.test_camera)
-        self.camera_service._run_action.assert_awaited_with(self.test_camera, "power_on")
-
-        await self.camera_service.turn_off(self.test_camera)
-        self.camera_service._run_action.assert_awaited_with(self.test_camera, "power_off")
-
-    async def test_siren_control_legacy_camera(self):
-        await self.camera_service.siren_on(self.test_camera)
-        self.camera_service._run_action.assert_awaited_with(self.test_camera, "siren_on")
-
-        await self.camera_service.siren_off(self.test_camera)
-        self.camera_service._run_action.assert_awaited_with(self.test_camera, "siren_off")
-
-    async def test_floodlight_control_legacy_camera(self):
-        await self.camera_service.floodlight_on(self.test_camera)
-        self.camera_service._set_property.assert_awaited_with(
-            self.test_camera, 
-            PropertyIDs.ACCESSORY.value, 
-            "1"
-        )
-
-        await self.camera_service.floodlight_off(self.test_camera)
-        self.camera_service._set_property.assert_awaited_with(
-            self.test_camera, 
-            PropertyIDs.ACCESSORY.value, 
-            "2"
-        )
-
-    async def test_notification_control_legacy_camera(self):
-        await self.camera_service.turn_on_notifications(self.test_camera)
-        self.camera_service._set_property.assert_awaited_with(
-            self.test_camera,
-            PropertyIDs.NOTIFICATION.value,
-            "1"
-        )
-
-        await self.camera_service.turn_off_notifications(self.test_camera)
-        self.camera_service._set_property.assert_awaited_with(
-            self.test_camera,
-            PropertyIDs.NOTIFICATION.value,
-            "0"
-        )
-
-    async def test_motion_detection_control_legacy_camera(self):
-        await self.camera_service.turn_on_motion_detection(self.test_camera)
-        self.camera_service._set_property.assert_any_await(
-            self.test_camera,
-            PropertyIDs.MOTION_DETECTION.value,
-            "1"
-        )
-        self.camera_service._set_property.assert_any_await(
-            self.test_camera,
-            PropertyIDs.MOTION_DETECTION_TOGGLE.value,
-            "1"
-        )
-
-        await self.camera_service.turn_off_motion_detection(self.test_camera)
-        self.camera_service._set_property.assert_any_await(
-            self.test_camera,
-            PropertyIDs.MOTION_DETECTION.value,
-            "0"
-        )
-        self.camera_service._set_property.assert_any_await(
-            self.test_camera,
-            PropertyIDs.MOTION_DETECTION_TOGGLE.value,
-            "0"
-        )
-
-if __name__ == '__main__':
-    unittest.main() 

wyzeapy/tests/test_hms_service.py

@@ -1,90 +0,0 @@
-import unittest
-from unittest.mock import AsyncMock, MagicMock
-from wyzeapy.services.hms_service import HMSService, HMSMode
-from wyzeapy.wyze_auth_lib import WyzeAuthLib
-
-class TestHMSService(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
-        self.hms_service = await HMSService.create(self.mock_auth_lib)
-        self.hms_service._get_plan_binding_list_by_user = AsyncMock()
-        self.hms_service._monitoring_profile_state_status = AsyncMock()
-        self.hms_service._monitoring_profile_active = AsyncMock()
-        self.hms_service._disable_reme_alarm = AsyncMock()
-
-    async def test_update_changing_mode(self):
-        self.hms_service._monitoring_profile_state_status.return_value = {'message': 'changing'}
-
-        mode = await self.hms_service.update('test_hms_id')
-        self.assertEqual(mode, HMSMode.CHANGING)
-
-    async def test_update_disarmed_mode(self):
-        self.hms_service._monitoring_profile_state_status.return_value = {'message': 'disarm'}
-
-        mode = await self.hms_service.update('test_hms_id')
-        self.assertEqual(mode, HMSMode.DISARMED)
-
-    async def test_update_away_mode(self):
-        self.hms_service._monitoring_profile_state_status.return_value = {'message': 'away'}
-
-        mode = await self.hms_service.update('test_hms_id')
-        self.assertEqual(mode, HMSMode.AWAY)
-
-    async def test_update_home_mode(self):
-        self.hms_service._monitoring_profile_state_status.return_value = {'message': 'home'}
-
-        mode = await self.hms_service.update('test_hms_id')
-        self.assertEqual(mode, HMSMode.HOME)
-
-    async def test_set_mode_disarmed(self):
-        self.hms_service._hms_id = 'test_hms_id'
-
-        await self.hms_service.set_mode(HMSMode.DISARMED)
-
-        self.hms_service._disable_reme_alarm.assert_awaited_with('test_hms_id')
-        self.hms_service._monitoring_profile_active.assert_awaited_with('test_hms_id', 0, 0)
-
-    async def test_set_mode_away(self):
-        self.hms_service._hms_id = 'test_hms_id'
-
-        await self.hms_service.set_mode(HMSMode.AWAY)
-
-        self.hms_service._monitoring_profile_active.assert_awaited_with('test_hms_id', 0, 1)
-
-    async def test_set_mode_home(self):
-        self.hms_service._hms_id = 'test_hms_id'
-
-        await self.hms_service.set_mode(HMSMode.HOME)
-
-        self.hms_service._monitoring_profile_active.assert_awaited_with('test_hms_id', 1, 0)
-
-    async def test_get_hms_id_with_existing_id(self):
-        self.hms_service._hms_id = 'existing_hms_id'
-        hms_id = await self.hms_service._get_hms_id()
-        self.assertEqual(hms_id, 'existing_hms_id')
-
-    async def test_get_hms_id_with_no_hms(self):
-        self.hms_service._hms_id = None
-        self.hms_service._get_plan_binding_list_by_user.return_value = {'data': []}
-
-        hms_id = await self.hms_service._get_hms_id()
-        self.assertIsNone(hms_id)
-
-    async def test_get_hms_id_finds_id(self):
-        self.hms_service._hms_id = None
-        self.hms_service._get_plan_binding_list_by_user.return_value = {
-            'data': [
-                {
-                    'deviceList': [
-                        {'device_id': 'found_hms_id'}
-                    ]
-                }
-            ]
-        }
-
-        hms_id = await self.hms_service._get_hms_id()
-        self.assertEqual(hms_id, 'found_hms_id')
-        self.assertEqual(self.hms_service._hms_id, 'found_hms_id')
-
-if __name__ == '__main__':
-    unittest.main() 

wyzeapy/tests/test_lock_service.py

@@ -1,114 +0,0 @@
-import unittest
-from unittest.mock import AsyncMock, MagicMock
-from wyzeapy.services.lock_service import LockService, Lock
-from wyzeapy.types import DeviceTypes
-from wyzeapy.exceptions import UnknownApiError
-
-class TestLockService(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        mock_auth_lib = MagicMock()
-        self.lock_service = LockService(auth_lib=mock_auth_lib)
-        self.lock_service._get_lock_info = AsyncMock()
-        self.lock_service._lock_control = AsyncMock()
-
-    async def test_update_lock_online(self):
-        mock_lock = Lock({
-            "device_type": "Lock",
-            "onoff_line": 1,
-            "door_open_status": 0,
-            "trash_mode": 0,
-            "locker_status": {"hardlock": 2},
-            "raw_dict": {}
-        })
-        self.lock_service._get_lock_info.return_value = {
-            "device": {
-                "onoff_line": 1,
-                "door_open_status": 0,
-                "trash_mode": 0,
-                "locker_status": {"hardlock": 2},
-            }
-        }
-
-        updated_lock = await self.lock_service.update(mock_lock)
-
-        self.assertTrue(updated_lock.available)
-        self.assertFalse(updated_lock.door_open)
-        self.assertFalse(updated_lock.trash_mode)
-        self.assertTrue(updated_lock.unlocked)
-        self.assertFalse(updated_lock.unlocking)
-        self.assertFalse(updated_lock.locking)
-        self.lock_service._get_lock_info.assert_awaited_once_with(mock_lock)
-
-    async def test_update_lock_offline(self):
-        mock_lock = Lock({
-            "device_type": "Lock",
-            "onoff_line": 0,
-            "door_open_status": 1,
-            "trash_mode": 1,
-            "locker_status": {"hardlock": 1},
-            "raw_dict": {}
-        })
-        self.lock_service._get_lock_info.return_value = {
-            "device": {
-                "onoff_line": 0,
-                "door_open_status": 1,
-                "trash_mode": 1,
-                "locker_status": {"hardlock": 1},
-            }
-        }
-
-        updated_lock = await self.lock_service.update(mock_lock)
-
-        self.assertFalse(updated_lock.available)
-        self.assertTrue(updated_lock.door_open)
-        self.assertTrue(updated_lock.trash_mode)
-        self.assertFalse(updated_lock.unlocked)
-        self.assertFalse(updated_lock.unlocking)
-        self.assertFalse(updated_lock.locking)
-        self.lock_service._get_lock_info.assert_awaited_once_with(mock_lock)
-
-    async def test_get_locks(self):
-        mock_device = AsyncMock()
-        mock_device.type = DeviceTypes.LOCK
-        mock_device.raw_dict = {"device_type": "Lock"}
-
-        self.lock_service.get_object_list = AsyncMock(return_value=[mock_device])
-
-        locks = await self.lock_service.get_locks()
-
-        self.assertEqual(len(locks), 1)
-        self.assertIsInstance(locks[0], Lock)
-        self.lock_service.get_object_list.assert_awaited_once()
-
-    async def test_lock(self):
-        mock_lock = Lock({
-            "device_type": "Lock",
-            "raw_dict": {}
-        })
-
-        await self.lock_service.lock(mock_lock)
-        self.lock_service._lock_control.assert_awaited_with(mock_lock, "remoteLock")
-
-    async def test_unlock(self):
-        mock_lock = Lock({
-            "device_type": "Lock",
-            "raw_dict": {}
-        })
-
-        await self.lock_service.unlock(mock_lock)
-        self.lock_service._lock_control.assert_awaited_with(mock_lock, "remoteUnlock")
-
-    async def test_lock_control_error_handling(self):
-        mock_lock = Lock({
-            "device_type": "Lock",
-            "raw_dict": {}
-        })
-        self.lock_service._lock_control.side_effect = UnknownApiError("Failed to lock/unlock")
-
-        with self.assertRaises(UnknownApiError):
-            await self.lock_service.lock(mock_lock)
-
-        with self.assertRaises(UnknownApiError):
-            await self.lock_service.unlock(mock_lock)
-
-# ... other test cases ... 

wyzeapy/tests/test_sensor_service.py

@@ -1,159 +0,0 @@
-import unittest
-from unittest.mock import AsyncMock, MagicMock
-from wyzeapy.services.sensor_service import SensorService, Sensor
-from wyzeapy.types import DeviceTypes, PropertyIDs
-from wyzeapy.wyze_auth_lib import WyzeAuthLib
-
-
-class TestSensorService(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
-        self.sensor_service = SensorService(auth_lib=self.mock_auth_lib)
-        self.sensor_service._get_device_info = AsyncMock()
-        self.sensor_service.get_updated_params = AsyncMock()
-        self.sensor_service.get_object_list = AsyncMock()
-        
-        # Reset the class-level subscribers list
-        self.sensor_service._subscribers = []
-
-        # Create test sensors
-        self.motion_sensor = Sensor({
-            "device_type": DeviceTypes.MOTION_SENSOR.value,
-            "product_model": "PIR3U",
-            "mac": "MOTION123",
-            "nickname": "Test Motion Sensor",
-            "device_params": {"ip": "192.168.1.100"},
-            "raw_dict": {}
-        })
-
-        self.contact_sensor = Sensor({
-            "device_type": DeviceTypes.CONTACT_SENSOR.value,
-            "product_model": "DWS3U",
-            "mac": "CONTACT456",
-            "nickname": "Test Contact Sensor",
-            "device_params": {"ip": "192.168.1.101"},
-            "raw_dict": {}
-        })
-
-    async def test_update_motion_sensor_detected(self):
-        self.sensor_service._get_device_info.return_value = {
-            'data': {
-                'property_list': [
-                    {
-                        'pid': PropertyIDs.MOTION_STATE.value,
-                        'value': '1'
-                    }
-                ]
-            }
-        }
-
-        updated_sensor = await self.sensor_service.update(self.motion_sensor)
-        self.assertTrue(updated_sensor.detected)
-
-    async def test_update_motion_sensor_not_detected(self):
-        self.sensor_service._get_device_info.return_value = {
-            'data': {
-                'property_list': [
-                    {
-                        'pid': PropertyIDs.MOTION_STATE.value,
-                        'value': '0'
-                    }
-                ]
-            }
-        }
-
-        updated_sensor = await self.sensor_service.update(self.motion_sensor)
-        self.assertFalse(updated_sensor.detected)
-
-    async def test_update_contact_sensor_detected(self):
-        self.sensor_service._get_device_info.return_value = {
-            'data': {
-                'property_list': [
-                    {
-                        'pid': PropertyIDs.CONTACT_STATE.value,
-                        'value': '1'
-                    }
-                ]
-            }
-        }
-
-        updated_sensor = await self.sensor_service.update(self.contact_sensor)
-        self.assertTrue(updated_sensor.detected)
-
-    async def test_update_contact_sensor_not_detected(self):
-        self.sensor_service._get_device_info.return_value = {
-            'data': {
-                'property_list': [
-                    {
-                        'pid': PropertyIDs.CONTACT_STATE.value,
-                        'value': '0'
-                    }
-                ]
-            }
-        }
-
-        updated_sensor = await self.sensor_service.update(self.contact_sensor)
-        self.assertFalse(updated_sensor.detected)
-
-    async def test_get_sensors(self):
-        mock_motion_device = MagicMock()
-        mock_motion_device.type = DeviceTypes.MOTION_SENSOR
-        mock_motion_device.raw_dict = {
-            "device_type": DeviceTypes.MOTION_SENSOR.value,
-            "product_model": "PIR3U",
-            "mac": "MOTION123"
-        }
-
-        mock_contact_device = MagicMock()
-        mock_contact_device.type = DeviceTypes.CONTACT_SENSOR
-        mock_contact_device.raw_dict = {
-            "device_type": DeviceTypes.CONTACT_SENSOR.value,
-            "product_model": "DWS3U",
-            "mac": "CONTACT456"
-        }
-
-        self.sensor_service.get_object_list.return_value = [
-            mock_motion_device,
-            mock_contact_device
-        ]
-
-        sensors = await self.sensor_service.get_sensors()
-        
-        self.assertEqual(len(sensors), 2)
-        self.assertIsInstance(sensors[0], Sensor)
-        self.assertIsInstance(sensors[1], Sensor)
-        self.sensor_service.get_object_list.assert_awaited_once()
-
-    async def test_register_for_updates(self):
-        mock_callback = MagicMock()
-        await self.sensor_service.register_for_updates(self.motion_sensor, mock_callback)
-        
-        self.assertEqual(len(self.sensor_service._subscribers), 1)
-        self.assertEqual(self.sensor_service._subscribers[0][0], self.motion_sensor)
-        self.assertEqual(self.sensor_service._subscribers[0][1], mock_callback)
-
-    async def test_deregister_for_updates(self):
-        mock_callback = MagicMock()
-        await self.sensor_service.register_for_updates(self.motion_sensor, mock_callback)
-        await self.sensor_service.deregister_for_updates(self.motion_sensor)
-        
-        self.assertEqual(len(self.sensor_service._subscribers), 0)
-
-    async def test_update_with_unknown_property(self):
-        self.sensor_service._get_device_info.return_value = {
-            'data': {
-                'property_list': [
-                    {
-                        'pid': 'unknown_property',
-                        'value': '1'
-                    }
-                ]
-            }
-        }
-
-        updated_sensor = await self.sensor_service.update(self.motion_sensor)
-        self.assertFalse(updated_sensor.detected)  # Should maintain default value
-
-
-if __name__ == '__main__':
-    unittest.main()