wyzeapy 0.5.27__py3-none-any.whl → 0.5.29__py3-none-any.whl

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()

wyzeapy/tests/test_switch_service.py

@@ -1,138 +0,0 @@
-import unittest
-from datetime import datetime, timedelta
-from unittest.mock import AsyncMock, MagicMock
-from wyzeapy.services.switch_service import SwitchService, SwitchUsageService, Switch
-from wyzeapy.types import DeviceTypes, PropertyIDs
-from wyzeapy.wyze_auth_lib import WyzeAuthLib
-
-
-class TestSwitchService(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
-        self.switch_service = SwitchService(auth_lib=self.mock_auth_lib)
-        self.switch_service._get_property_list = AsyncMock()
-        self.switch_service.get_updated_params = AsyncMock()
-        self.switch_service.get_object_list = AsyncMock()
-        self.switch_service._set_property = AsyncMock()
-
-        # Create test switch
-        self.test_switch = Switch({
-            "device_type": DeviceTypes.PLUG.value,
-            "product_model": "WLPP1",
-            "mac": "SWITCH123",
-            "nickname": "Test Switch",
-            "device_params": {"ip": "192.168.1.100"},
-            "raw_dict": {}
-        })
-
-    async def test_update_switch_on(self):
-        self.switch_service._get_property_list.return_value = [
-            (PropertyIDs.ON, "1"),
-            (PropertyIDs.AVAILABLE, "1")
-        ]
-
-        updated_switch = await self.switch_service.update(self.test_switch)
-        
-        self.assertTrue(updated_switch.on)
-        self.assertTrue(updated_switch.available)
-
-    async def test_update_switch_off(self):
-        self.switch_service._get_property_list.return_value = [
-            (PropertyIDs.ON, "0"),
-            (PropertyIDs.AVAILABLE, "1")
-        ]
-
-        updated_switch = await self.switch_service.update(self.test_switch)
-        
-        self.assertFalse(updated_switch.on)
-        self.assertTrue(updated_switch.available)
-
-    async def test_get_switches(self):
-        mock_plug = MagicMock()
-        mock_plug.type = DeviceTypes.PLUG
-        mock_plug.raw_dict = {
-            "device_type": DeviceTypes.PLUG.value,
-            "product_model": "WLPP1",
-            "mac": "PLUG123"
-        }
-
-        mock_outdoor_plug = MagicMock()
-        mock_outdoor_plug.type = DeviceTypes.OUTDOOR_PLUG
-        mock_outdoor_plug.raw_dict = {
-            "device_type": DeviceTypes.OUTDOOR_PLUG.value,
-            "product_model": "WLPPO",
-            "mac": "OUTPLUG456"
-        }
-
-        self.switch_service.get_object_list.return_value = [
-            mock_plug,
-            mock_outdoor_plug
-        ]
-
-        switches = await self.switch_service.get_switches()
-        
-        self.assertEqual(len(switches), 2)
-        self.assertIsInstance(switches[0], Switch)
-        self.assertIsInstance(switches[1], Switch)
-        self.switch_service.get_object_list.assert_awaited_once()
-
-    async def test_turn_on(self):
-        await self.switch_service.turn_on(self.test_switch)
-        self.switch_service._set_property.assert_awaited_with(
-            self.test_switch,
-            PropertyIDs.ON.value,
-            "1"
-        )
-
-    async def test_turn_off(self):
-        await self.switch_service.turn_off(self.test_switch)
-        self.switch_service._set_property.assert_awaited_with(
-            self.test_switch,
-            PropertyIDs.ON.value,
-            "0"
-        )
-
-
-class TestSwitchUsageService(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        self.mock_auth_lib = MagicMock(spec=WyzeAuthLib)
-        self.usage_service = SwitchUsageService(auth_lib=self.mock_auth_lib)
-        self.usage_service._get_plug_history = AsyncMock()
-
-        # Create test switch
-        self.test_switch = Switch({
-            "device_type": DeviceTypes.PLUG.value,
-            "product_model": "WLPP1",
-            "mac": "SWITCH123",
-            "nickname": "Test Switch",
-            "device_params": {"ip": "192.168.1.100"},
-            "raw_dict": {}
-        })
-
-    async def test_update_usage_history(self):
-        mock_usage_data = {
-            "total_power": 100,
-            "time_series": [
-                {"power": 10, "timestamp": 1234567890},
-                {"power": 20, "timestamp": 1234567891}
-            ]
-        }
-        self.usage_service._get_plug_history.return_value = mock_usage_data
-
-        # Calculate expected timestamps
-        now = datetime.now()
-        expected_end_time = int(datetime.timestamp(now) * 1000)
-        expected_start_time = int(datetime.timestamp(now - timedelta(hours=25)) * 1000)
-
-        updated_switch = await self.usage_service.update(self.test_switch)
-
-        self.assertEqual(updated_switch.usage_history, mock_usage_data)
-        self.usage_service._get_plug_history.assert_awaited_with(
-            self.test_switch,
-            expected_start_time,
-            expected_end_time
-        )
-
-
-if __name__ == '__main__':
-    unittest.main()