async def test_process_callback_always(self): """Test process / reading telegrams from telegram queue. Test if callback is called.""" xknx = XKNX() sensor = NumericValue( xknx, "TestSensor", group_address="1/2/3", value_type="temperature", always_callback=True, ) after_update_callback = AsyncMock() sensor.register_device_updated_cb(after_update_callback) telegram = Telegram( destination_address=GroupAddress("1/2/3"), payload=GroupValueWrite(DPTArray((0x01, 0x02))), ) await sensor.process(telegram) after_update_callback.assert_called_with(sensor) assert sensor.last_telegram == telegram # every telegram shall trigger callback after_update_callback.reset_mock() await sensor.process(telegram) after_update_callback.assert_called_with(sensor)
async def test_auto_pull_tag_when_missing(agent, mocker): behavior = AutoPullBehavior.TAG inspect_mock = AsyncMock(side_effect=DockerError( status=404, data={'message': 'Simulated missing image'})) mocker.patch.object(agent.docker.images, 'inspect', new=inspect_mock) pull = await agent.check_image(imgref, query_digest, behavior) assert pull inspect_mock.assert_called_with(imgref.canonical)
def test_scraper(self, mock_save, mock_read: AsyncMock, mock_update_cache, mock_delete): asyncio.run(check_new_posts()) mock_read.assert_called_with("https://news.ycombinator.com/") mock_delete.assert_called_once() mock_update_cache.assert_called_once() assert mock_save.call_count == 30
async def test_sync_setup_entry_multiple_discoveries(hass: HomeAssistant): """Test async_setup_entry.""" udn_0 = "uuid:device_1" location_0 = "http://192.168.1.1/desc.xml" mock_device_0 = MockDevice(udn_0) udn_1 = "uuid:device_2" location_1 = "http://192.168.1.2/desc.xml" mock_device_1 = MockDevice(udn_1) discoveries = [ { DISCOVERY_LOCATION: location_0, DISCOVERY_NAME: mock_device_0.name, DISCOVERY_ST: mock_device_0.device_type, DISCOVERY_UDN: mock_device_0.udn, DISCOVERY_UNIQUE_ID: mock_device_0.unique_id, DISCOVERY_USN: mock_device_0.usn, DISCOVERY_HOSTNAME: mock_device_0.hostname, }, { DISCOVERY_LOCATION: location_1, DISCOVERY_NAME: mock_device_1.name, DISCOVERY_ST: mock_device_1.device_type, DISCOVERY_UDN: mock_device_1.udn, DISCOVERY_UNIQUE_ID: mock_device_1.unique_id, DISCOVERY_USN: mock_device_1.usn, DISCOVERY_HOSTNAME: mock_device_1.hostname, }, ] entry = MockConfigEntry( domain=DOMAIN, data={ CONFIG_ENTRY_UDN: mock_device_1.udn, CONFIG_ENTRY_ST: mock_device_1.device_type, }, ) config = { # no upnp } async_create_device = AsyncMock(return_value=mock_device_1) async_discover = AsyncMock() with patch.object(Device, "async_create_device", async_create_device), patch.object( Device, "async_discover", async_discover): # initialisation of component, no device discovered async_discover.return_value = [] await async_setup_component(hass, "upnp", config) await hass.async_block_till_done() # loading of config_entry, device discovered async_discover.return_value = discoveries entry.add_to_hass(hass) assert await hass.config_entries.async_setup(entry.entry_id) is True # ensure device is stored/used async_create_device.assert_called_with( hass, discoveries[1][DISCOVERY_LOCATION])
async def test_emit(self): probe = AsyncMock() sub = SubscriptionConsumer( Application(), Subscription("foo", lambda record: 1, "group"), event_handlers={"event": [probe]}, ) await sub.emit("event", "foo", "bar") probe.assert_called_with("foo", "bar")
async def test_auto_pull_none_when_missing(agent, mocker): behavior = AutoPullBehavior.NONE inspect_mock = AsyncMock(side_effect=DockerError( status=404, data={'message': 'Simulated missing image'})) mocker.patch.object(agent.docker.images, 'inspect', new=inspect_mock) with pytest.raises(ImageNotAvailable) as e: await agent.check_image(imgref, query_digest, behavior) assert e.value.args[0] is imgref inspect_mock.assert_called_with(imgref.canonical)
async def test_ports(): """Test that different types of ports work.""" mock_requests = AsyncMock(return_value=Future()) mock_requests.return_value.set_result("") wlans = Wlans(WLANS, mock_requests) assert len(wlans.values()) == 2 wlan = wlans["SSID 1"] assert wlan.id == "012345678910111213141516" assert wlan.bc_filter_enabled == False assert wlan.bc_filter_list == [] assert wlan.dtim_mode == "default" assert wlan.dtim_na == 1 assert wlan.dtim_ng == 1 assert wlan.enabled is True assert wlan.group_rekey == 3600 assert wlan.is_guest is False assert wlan.mac_filter_enabled is False assert wlan.mac_filter_list == [] assert wlan.mac_filter_policy == "allow" assert wlan.minrate_na_advertising_rates is False assert wlan.minrate_na_beacon_rate_kbps == 6000 assert wlan.minrate_na_data_rate_kbps == 6000 assert wlan.minrate_na_enabled is False assert wlan.minrate_na_mgmt_rate_kbps == 6000 assert wlan.minrate_ng_advertising_rates is False assert wlan.minrate_ng_beacon_rate_kbps == 1000 assert wlan.minrate_ng_cck_rates_enabled is False assert wlan.minrate_ng_data_rate_kbps == 1000 assert wlan.minrate_ng_enabled is False assert wlan.minrate_ng_mgmt_rate_kbps == 1000 assert wlan.name == "SSID 1" assert wlan.name_combine_enabled is True assert wlan.name_combine_suffix == "" assert wlan.no2ghz_oui is False assert wlan.schedule == [] assert wlan.security == "wpapsk" assert wlan.site_id == "5a32aa4ee4b0412345678910" assert wlan.usergroup_id == "012345678910111213141518" assert wlan.wep_idx == 1 assert wlan.wlangroup_id == "012345678910111213141519" assert wlan.wpa_enc == "ccmp" assert wlan.wpa_mode == "wpa2" assert wlan.x_iapp_key == "01234567891011121314151617181920" assert wlan.x_passphrase == "password in clear text" await wlans.async_enable(wlan) mock_requests.assert_called_with("put", "/rest/wlanconf/012345678910111213141516", json={"enabled": True}) await wlans.async_disable(wlan) mock_requests.assert_called_with("put", "/rest/wlanconf/012345678910111213141516", json={"enabled": False})
async def test_emit(self, subscription_conf): probe = AsyncMock() sub = BatchConsumer( subscription=subscription_conf, app=Application(kafka_servers=["foobar"]), event_handlers={"event": [probe]}, ) await sub.emit("event", "foo", "bar") probe.assert_called_with("foo", "bar")
async def test_device_updated_cb(self): """Test device updated cb is added to the device.""" xknx = XKNX() after_update_callback = AsyncMock() device = Device(xknx, "TestDevice", device_updated_cb=after_update_callback) await device.after_update() after_update_callback.assert_called_with(device)
async def test_call_response_handlers(monkeypatch): monkeypatch.setattr("chitanda.bot.config", {"webserver": {"enable": True}}) handler1 = AsyncMock(return_value=True) handler2 = AsyncMock(return_value=True) chitanda = Chitanda() with patch.object(chitanda, "response_handlers") as handlers: handlers.__iter__.return_value = [handler1, handler2] await chitanda.call_response_handlers("abc") handler1.assert_called_with("abc") handler2.assert_called_with("abc")
async def test_process_rpc_query_no_tags( self, mocked_get_entries_threaded: AsyncMock): # test that in case of missed tags, the remote search works like normal remote search parameters = {'first': 0, 'infohash_set': None, 'last': 100} json = dumps(parameters).encode('utf-8') await self.rqc.process_rpc_query(json) expected_parameters = {'infohash_set': None} expected_parameters.update(parameters) mocked_get_entries_threaded.assert_called_with(**expected_parameters)
async def test_run_adhoc_job(self): job = http_job() handler = AsyncMock() await adhoc.run_adhoc_job( mock_adhoc_job_model, handler, job ) handler.assert_called_with(job) mock_adhoc_job_model.set_job_completed \ .assert_called_with(job.job_id) return
async def test_run_task(self, runner, db): task_func = AsyncMock() task = Mock() task.name = "test" task.data = pickle.dumps(FooType(foo="foo")) with patch.dict( taskrunner._registered, {"test": (task_func, FooType)}, clear=True ): await runner.run_task(task) task_func.assert_called_with(runner, ANY)
async def test_process_callback_set(self): """Test setting value. Test if callback is called.""" xknx = XKNX() after_update_callback = AsyncMock() num_value = NumericValue( xknx, "TestSensor", group_address="1/2/3", value_type="temperature" ) num_value.register_device_updated_cb(after_update_callback) await num_value.set(21.0) await xknx.devices.process(xknx.telegrams.get_nowait()) after_update_callback.assert_called_with(num_value)
async def test_process_callback(self): """Test process / reading telegrams from telegram queue. Test if callback was called.""" xknx = XKNX() notification = Notification(xknx, "Warning", group_address="1/2/3") after_update_callback = AsyncMock() notification.register_device_updated_cb(after_update_callback) telegram_set = Telegram( destination_address=GroupAddress("1/2/3"), payload=GroupValueWrite(DPTArray( DPTString().to_knx("Ein Prosit!"))), ) await notification.process(telegram_set) after_update_callback.assert_called_with(notification)
async def test_device_updated_callback(self): """Test if device updated callback is called correctly if device was updated.""" xknx = XKNX() device1 = Device(xknx, "TestDevice1") device2 = Device(xknx, "TestDevice2") async_after_update_callback1 = AsyncMock() async_after_update_callback2 = AsyncMock() # Registering both callbacks xknx.devices.register_device_updated_cb(async_after_update_callback1) xknx.devices.register_device_updated_cb(async_after_update_callback2) # Triggering first device. Both callbacks to be called await device1.after_update() async_after_update_callback1.assert_called_with(device1) async_after_update_callback2.assert_called_with(device1) async_after_update_callback1.reset_mock() async_after_update_callback2.reset_mock() # Triggering 2nd device. Both callbacks have to be called await device2.after_update() async_after_update_callback1.assert_called_with(device2) async_after_update_callback2.assert_called_with(device2) async_after_update_callback1.reset_mock() async_after_update_callback2.reset_mock() # Unregistering first callback xknx.devices.unregister_device_updated_cb(async_after_update_callback1) # Triggering first device. Only second callback has to be called await device1.after_update() async_after_update_callback1.assert_not_called() async_after_update_callback2.assert_called_with(device1) async_after_update_callback1.reset_mock() async_after_update_callback2.reset_mock() # Unregistering second callback xknx.devices.unregister_device_updated_cb(async_after_update_callback2) # Triggering second device. No callback should be called await device2.after_update() async_after_update_callback1.assert_not_called() async_after_update_callback2.assert_not_called() async_after_update_callback1.reset_mock() async_after_update_callback2.reset_mock()
async def test_callback_no_filters(self): """Test telegram_received_callback after state of switch was changed.""" xknx = XKNX() async_telegram_received_callback = AsyncMock() xknx.telegram_queue.register_telegram_received_cb( async_telegram_received_callback) telegram = Telegram( destination_address=GroupAddress("1/2/3"), direction=TelegramDirection.INCOMING, payload=GroupValueWrite(DPTBinary(1)), ) xknx.telegrams.put_nowait(telegram) await xknx.telegram_queue._process_all_telegrams() async_telegram_received_callback.assert_called_with(telegram)
async def test_websocket_accept_connection(scope: dict, headers: Headers, subprotocol: Optional[str], has_headers: bool) -> None: connection = ASGIWebsocketConnection(Quart(__name__), scope) mock_send = AsyncMock() await connection.accept_connection(mock_send, headers, subprotocol) if has_headers: mock_send.assert_called_with({ "subprotocol": subprotocol, "type": "websocket.accept", "headers": encode_headers(headers), }) else: mock_send.assert_called_with({ "subprotocol": subprotocol, "type": "websocket.accept" })
async def test_process_callback(self): """Test process / reading telegrams from telegram queue. Test if callback is executed.""" xknx = XKNX() cover = Cover( xknx, "TestCoverProcessCallback", group_address_long="1/2/1", group_address_short="1/2/2", group_address_stop="1/2/3", group_address_position="1/2/4", group_address_position_state="1/2/5", group_address_angle="1/2/6", group_address_angle_state="1/2/7", ) after_update_callback = AsyncMock() cover.register_device_updated_cb(after_update_callback) for address, payload, _feature in [ ("1/2/1", DPTBinary(1), "long"), ("1/2/2", DPTBinary(1), "short"), ("1/2/4", DPTArray(42), "position"), ("1/2/5", DPTArray(42), "position state"), ("1/2/6", DPTArray(42), "angle"), ("1/2/7", DPTArray(51), "angle state"), ]: telegram = Telegram( destination_address=GroupAddress(address), payload=GroupValueWrite(payload), ) await cover.process(telegram) after_update_callback.assert_called_with(cover) after_update_callback.reset_mock() # Stop only when cover is travelling telegram = Telegram(GroupAddress("1/2/3"), payload=GroupValueWrite(DPTBinary(1))) await cover.process(telegram) after_update_callback.assert_not_called() await cover.set_down() await cover.process(telegram) after_update_callback.assert_called_with(cover) await cover.stop() # clean up tasks
async def test_clients(): """Test clients class.""" mock_requests = AsyncMock(return_value=Future()) mock_requests.return_value.set_result("") clients = Clients([WIRELESS_CLIENT], mock_requests) assert len(clients.values()) == 1 client = clients[WIRELESS_CLIENT["mac"]] assert client.blocked is False assert client.essid == "SSID" assert client.hostname == "client" assert client.ip == "10.0.0.1" assert client.is_guest is False assert client.is_wired is False assert client.last_seen == 1587765360 assert client.mac == WIRELESS_CLIENT["mac"] assert client.name == "Client 1" assert client.oui == "Apple" assert client.site_id == "5a32aa4ee4b0412345678910" assert client.sw_depth == -1 assert client.sw_mac == "fc:ec:da:11:22:33" assert client.sw_port == 1 assert client.rx_bytes == 12867114 assert client.tx_bytes == 52852089 assert client.uptime == 11904 assert client.wired_rx_bytes == 0 assert client.wired_tx_bytes == 0 assert ( client.__repr__() == f"<Client Client 1: 00:00:00:00:00:01 {WIRELESS_CLIENT}>" ) await clients.async_block(WIRELESS_CLIENT["mac"]) mock_requests.assert_called_with( "post", "/cmd/stamgr", json={"mac": WIRELESS_CLIENT["mac"], "cmd": "block-sta"} ) await clients.async_unblock(WIRELESS_CLIENT["mac"]) mock_requests.assert_called_with( "post", "/cmd/stamgr", json={"mac": WIRELESS_CLIENT["mac"], "cmd": "unblock-sta"}, )
async def test_load_unload_config_entry( hass: HomeAssistant, mock_connection_create: AsyncMock, mock_anthemav: AsyncMock, init_integration: MockConfigEntry, ) -> None: """Test load and unload AnthemAv component.""" # assert avr is created mock_connection_create.assert_called_with(host="1.1.1.1", port=14999, update_callback=ANY) assert init_integration.state == config_entries.ConfigEntryState.LOADED # unload await hass.config_entries.async_unload(init_integration.entry_id) await hass.async_block_till_done() # assert unload and avr is closed assert init_integration.state == config_entries.ConfigEntryState.NOT_LOADED mock_anthemav.close.assert_called_once()
async def test_async_setup_entry_default(opp: OpenPeerPower): """Test async_setup_entry.""" udn = "uuid:device_1" location = "http://192.168.1.1/desc.xml" mock_device = MockDevice(udn) discoveries = [{ DISCOVERY_LOCATION: location, DISCOVERY_NAME: mock_device.name, DISCOVERY_ST: mock_device.device_type, DISCOVERY_UDN: mock_device.udn, DISCOVERY_UNIQUE_ID: mock_device.unique_id, DISCOVERY_USN: mock_device.usn, DISCOVERY_HOSTNAME: mock_device.hostname, }] entry = MockConfigEntry( domain=DOMAIN, data={ CONFIG_ENTRY_UDN: mock_device.udn, CONFIG_ENTRY_ST: mock_device.device_type, }, ) config = { # no upnp } async_create_device = AsyncMock(return_value=mock_device) async_discover = AsyncMock() with patch.object(Device, "async_create_device", async_create_device), patch.object( Device, "async_discover", async_discover): # initialisation of component, no device discovered async_discover.return_value = [] await async_setup_component(opp, "upnp", config) await opp.async_block_till_done() # loading of config_entry, device discovered async_discover.return_value = discoveries entry.add_to_opp(opp) assert await opp.config_entries.async_setup(entry.entry_id) is True # ensure device is stored/used async_create_device.assert_called_with( opp, discoveries[0][DISCOVERY_LOCATION])
async def test_async_setup_entry_default(hass: HomeAssistant): """Test async_setup_entry.""" udn = "uuid:device_1" location = "http://192.168.1.1/desc.xml" mock_device = MockDevice(udn) discovery = { ssdp.ATTR_SSDP_LOCATION: location, ssdp.ATTR_SSDP_ST: mock_device.device_type, ssdp.ATTR_UPNP_UDN: mock_device.udn, ssdp.ATTR_SSDP_USN: mock_device.usn, } entry = MockConfigEntry( domain=DOMAIN, data={ CONFIG_ENTRY_UDN: mock_device.udn, CONFIG_ENTRY_ST: mock_device.device_type, }, ) config = { # no upnp } async_create_device = AsyncMock(return_value=mock_device) mock_get_discovery = Mock() with patch.object(Device, "async_create_device", async_create_device), patch.object( ssdp, "async_get_discovery_info_by_udn_st", mock_get_discovery): # initialisation of component, no device discovered mock_get_discovery.return_value = None await async_setup_component(hass, "upnp", config) await hass.async_block_till_done() # loading of config_entry, device discovered mock_get_discovery.return_value = discovery entry.add_to_hass(hass) assert await hass.config_entries.async_setup(entry.entry_id) is True # ensure device is stored/used async_create_device.assert_called_with( hass, discovery[ssdp.ATTR_SSDP_LOCATION])
async def test_process_callback_ignore_internal_state(self): """Test after_update_callback after state of switch was changed.""" xknx = XKNX() switch = BinarySensor( xknx, "TestInput", group_address_state="1/2/3", ignore_internal_state=True, context_timeout=0.001, ) async_after_update_callback = AsyncMock() switch.register_device_updated_cb(async_after_update_callback) telegram = Telegram( destination_address=GroupAddress("1/2/3"), payload=GroupValueWrite(DPTBinary(1)), ) assert switch.counter == 0 await switch.process(telegram) async_after_update_callback.assert_not_called() assert switch.counter == 1 await switch._context_task async_after_update_callback.assert_called_with(switch) # once with counter 1 and once with counter 0 assert async_after_update_callback.call_count == 2 async_after_update_callback.reset_mock() # send same telegram again await switch.process(telegram) assert switch.counter == 1 await switch.process(telegram) assert switch.counter == 2 async_after_update_callback.assert_not_called() await switch._context_task async_after_update_callback.assert_called_with(switch) # once with counter 2 and once with counter 0 assert async_after_update_callback.call_count == 2 assert switch.counter == 0
async def test_schedule_adhoc_jobs(self): loop = asyncio.get_event_loop() scheduler_state = await mock_adhoc_scheduler() now = time.time() handler = AsyncMock() spacing = 0.01 jobs = [ adhoc_job( "job" + str(now + (i * spacing)), now + (i * spacing) ) for i in range(1, 5) ] adhoc.schedule_adhoc_jobs( scheduler_state, loop, jobs, handler, ) for i in range(1, 5): await asyncio.sleep(spacing) handler.assert_called_with(jobs[i - 1]) return
async def test_process_callback(self): """Test process / reading telegrams from telegram queue. Test if callback was called.""" xknx = XKNX() device = Device(xknx, "TestDevice") after_update_callback1 = AsyncMock() after_update_callback2 = AsyncMock() device.register_device_updated_cb(after_update_callback1) device.register_device_updated_cb(after_update_callback2) # Triggering first time. Both have to be called await device.after_update() after_update_callback1.assert_called_with(device) after_update_callback2.assert_called_with(device) after_update_callback1.reset_mock() after_update_callback2.reset_mock() # Triggering 2nd time. Both have to be called await device.after_update() after_update_callback1.assert_called_with(device) after_update_callback2.assert_called_with(device) after_update_callback1.reset_mock() after_update_callback2.reset_mock() # Unregistering first callback device.unregister_device_updated_cb(after_update_callback1) await device.after_update() after_update_callback1.assert_not_called() after_update_callback2.assert_called_with(device) after_update_callback1.reset_mock() after_update_callback2.reset_mock() # Unregistering second callback device.unregister_device_updated_cb(after_update_callback2) await device.after_update() after_update_callback1.assert_not_called() after_update_callback2.assert_not_called()
async def test_process_callback(self): """Test process / reading telegrams from telegram queue. Test if callback is called.""" xknx = XKNX() sensor = RawValue( xknx, "TestSensor", 2, group_address="1/2/3", ) after_update_callback = AsyncMock() sensor.register_device_updated_cb(after_update_callback) telegram = Telegram( destination_address=GroupAddress("1/2/3"), payload=GroupValueWrite(DPTArray((0x01, 0x02))), ) await sensor.process(telegram) after_update_callback.assert_called_with(sensor) assert sensor.last_telegram == telegram # consecutive telegrams with same payload shall only trigger one callback after_update_callback.reset_mock() await sensor.process(telegram) after_update_callback.assert_not_called()
async def test_dpi_groups(): """Test that different types of ports work.""" mock_requests = AsyncMock(return_value=Future()) mock_requests.return_value.set_result("") dpi_apps = DPIRestrictionApps(DPI_APPS, mock_requests) dpi_groups = DPIRestrictionGroups(DPI_GROUPS, mock_requests, dpi_apps) assert len(dpi_apps.values()) == 1 assert len(dpi_groups.values()) == 2 app: DPIRestrictionApp = dpi_apps["5f976f62e3c58f018ec7e17d"] assert app.id == "5f976f62e3c58f018ec7e17d" assert app.apps == [] assert app.blocked assert app.cats == ["4"] assert app.enabled assert app.log assert app.site_id == "5ba29dd4e3c58f026e9d7c38" group: DPIRestrictionGroup = dpi_groups["5f976f4ae3c58f018ec7dff6"] assert group.id == "5f976f4ae3c58f018ec7dff6" assert not group.attr_no_delete assert group.attr_hidden_id == "" assert group.name == "No Media" assert group.site_id == "5ba29dd4e3c58f026e9d7c38" assert group.dpiapp_ids == ["5f976f62e3c58f018ec7e17d"] await dpi_groups.async_enable(group) mock_requests.assert_called_with("put", "/rest/dpiapp/5f976f62e3c58f018ec7e17d", json={"enabled": True}) await dpi_groups.async_disable(group) mock_requests.assert_called_with("put", "/rest/dpiapp/5f976f62e3c58f018ec7e17d", json={"enabled": False})
async def test_bad_callback(self, logging_exception_mock): """Test handling callback raising an exception""" xknx = XKNX() device = Device(xknx, "TestDevice") good_callback_1 = AsyncMock() bad_callback = AsyncMock(side_effect=Exception("Boom")) good_callback_2 = AsyncMock() device.register_device_updated_cb(good_callback_1) device.register_device_updated_cb(bad_callback) device.register_device_updated_cb(good_callback_2) await device.after_update() good_callback_1.assert_called_with(device) bad_callback.assert_called_with(device) good_callback_2.assert_called_with(device) logging_exception_mock.assert_called_once_with( "Unexpected error while processing device_updated_cb for %s", device, )
async def test_add_device_to_scene(self): """Test the add_device_to_scene command of the tools function.""" device_01 = create_device(DimmableLightingControl, random_address(), 0x01, 0x01) device_02 = create_device(SwitchedLightingControl, random_address(), 0x02, 0x02) device_05 = create_device(ClimateControl_Thermostat, random_address(), 0x05, 0x04) device_07 = create_device(SensorsActuators_IOLink, random_address(), 0x07, 0x03) devices[device_01.address] = device_01 devices[device_02.address] = device_02 devices[device_05.address] = device_05 devices[device_07.address] = device_07 mock_add_device_to_scene = AsyncMock() async with self.test_lock: with patch.object(pyinsteon.tools.aldb, "devices", devices), patch.object( pyinsteon.tools.tools_base, "devices", devices), patch.object( pyinsteon.tools.aldb, "async_add_device_to_scene", mock_add_device_to_scene, ): # Add default links with input mode and default values for data1, data2, data3 for device in [device_01, device_02, device_05, device_07]: scene = random.randint(0, 255) cmd_mgr, _, stdout = self.setup_cmd_tool( ToolsAldb, [ "add_device_to_scene", str(device.address), str(scene), "", "", "", "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 1 if device.cat == DeviceCategory.DIMMABLE_LIGHTING_CONTROL: mock_add_device_to_scene.assert_called_with( device, scene, 255, 28, 1) else: mock_add_device_to_scene.assert_called_with( device, scene, 255, 0, 1) # Add default links with command line and background mode and default values for data1, data2, data3 for device in [device_01, device_02, device_05, device_07]: for command in [ "add_device_to_scene", "add_device_to_scene -b" ]: scene = random.randint(0, 255) cmd_mgr, _, stdout = self.setup_cmd_tool( ToolsAldb, [ f"{command} {str(device.address)} {scene}", "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 1 if device.cat == DeviceCategory.DIMMABLE_LIGHTING_CONTROL: mock_add_device_to_scene.assert_called_with( device, scene, 255, 28, 1) else: mock_add_device_to_scene.assert_called_with( device, scene, 255, 0, 1) # Add default links with input mode with inputs for data1, data2, data3 for device in [device_01, device_02, device_05, device_07]: scene = random.randint(0, 255) if device.cat == 0x02: vals = [0, 255] data1 = vals[random.randint(0, 1)] else: data1 = random.randint(0, 255) if device.cat == 0x01: data2 = random.randint(0, 2400) / 10 else: data2 = random.randint(0, 255) data3 = random.randint(0, 255) cmd_mgr, _, stdout = self.setup_cmd_tool( ToolsAldb, [ "add_device_to_scene", str(device.address), str(scene), str(data1), str(data2), str(data3), "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 1 if device.cat == DeviceCategory.DIMMABLE_LIGHTING_CONTROL: mock_add_device_to_scene.assert_called_with( device, scene, data1, seconds_to_ramp_rate(data2), data3) else: mock_add_device_to_scene.assert_called_with( device, scene, data1, data2, data3) # Add default links with command line and background mode with inputs for data1, data2, data3 for device in [device_01, device_02, device_05, device_07]: for command in [ "add_device_to_scene", "add_device_to_scene -b" ]: scene = random.randint(0, 255) if device.cat == 0x02: vals = [0, 255] data1 = vals[random.randint(0, 1)] else: data1 = random.randint(0, 255) if device.cat == 0x01: data2 = random.randint(0, 2400) / 10 else: data2 = random.randint(0, 255) data3 = random.randint(0, 255) cmd_mgr, _, stdout = self.setup_cmd_tool( ToolsAldb, [ f"{command} {device.address} {scene} {data1} {data2} {data3}", "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 1 if device.cat == DeviceCategory.DIMMABLE_LIGHTING_CONTROL: mock_add_device_to_scene.assert_called_with( device, scene, data1, seconds_to_ramp_rate(data2), data3) else: mock_add_device_to_scene.assert_called_with( device, scene, data1, data2, data3) # Add default links with background mode with bad data for data1, data2, data3 for device in [device_01, device_02, device_05, device_07]: scene = random.randint(0, 255) data1 = ["x", 255, 255] data2 = [255, "x", 255] data3 = [255, 200, "x"] data4 = [300, 255, 255] data5 = [255, 3000, 255] data6 = [255, 255, 300] for data in [data1, data2, data3, data4, data5, data6]: cmd_mgr, _, stdout = self.setup_cmd_tool( ToolsAldb, [ f"add_device_to_scene -b {device.address} {scene} {data[0]} {data[1]} {data[2]}", "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 0 # Add device to scene with no address cmd_mgr, _, _ = self.setup_cmd_tool( ToolsAldb, [ "add_device_to_scene", "", "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 0 # Add device to scene in background mode with bad address cmd_mgr, _, _ = self.setup_cmd_tool( ToolsAldb, [ f"add_device_to_scene -b {bad_address}", "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 0 # Add device to scene in background mode with invalid address cmd_mgr, _, _ = self.setup_cmd_tool( ToolsAldb, [ "add_device_to_scene -b not.an.address 100", "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 0 # Add device to scene in background mode with invalid scene cmd_mgr, _, _ = self.setup_cmd_tool( ToolsAldb, [ f"add_device_to_scene -b {good_address} x", "exit", ], ) mock_add_device_to_scene.call_count = 0 await cmd_mgr.async_cmdloop("") assert mock_add_device_to_scene.call_count == 0