async def test_process_group_value_response(self): """Test precess of GroupValueResponse telegrams.""" xknx = XKNX() switch = BinarySensor( xknx, "TestInput", group_address_state="1/2/3", ignore_internal_state=True, ) async_after_update_callback = AsyncMock() switch.register_device_updated_cb(async_after_update_callback) write_telegram = Telegram( destination_address=GroupAddress("1/2/3"), payload=GroupValueWrite(DPTBinary(1)), ) response_telegram = Telegram( destination_address=GroupAddress("1/2/3"), payload=GroupValueResponse(DPTBinary(1), ), ) assert switch.state is None # initial GroupValueResponse changes state and runs callback await switch.process(response_telegram) assert switch.state async_after_update_callback.assert_called_once_with(switch) # GroupValueWrite with same payload runs callback because of `ignore_internal_state` async_after_update_callback.reset_mock() await switch.process(write_telegram) assert switch.state async_after_update_callback.assert_called_once_with(switch) # GroupValueResponse should not run callback when state has not changed async_after_update_callback.reset_mock() await switch.process(response_telegram) async_after_update_callback.assert_not_called()
async def test_check(coresys: CoreSys, dns_query: AsyncMock): """Test check for DNS server failures.""" dns_server_failures = CheckDNSServerFailures(coresys) coresys.core.state = CoreState.RUNNING coresys.plugins.dns.servers = ["dns://1.1.1.1"] assert dns_server_failures.dns_servers == [ "dns://1.1.1.1", "dns://192.168.30.1", ] assert len(coresys.resolution.issues) == 0 await dns_server_failures.run_check.__wrapped__(dns_server_failures) assert dns_query.call_args_list == [ call("_checkdns.home-assistant.io", "A"), call("_checkdns.home-assistant.io", "A"), ] assert len(coresys.resolution.issues) == 0 dns_query.reset_mock() coresys.plugins.dns.servers = [] assert dns_server_failures.dns_servers == ["dns://192.168.30.1"] dns_query.side_effect = DNSError() await dns_server_failures.run_check.__wrapped__(dns_server_failures) dns_query.assert_called_once_with("_checkdns.home-assistant.io", "A") assert len(coresys.resolution.issues) == 1 assert coresys.resolution.issues[0].type is IssueType.DNS_SERVER_FAILED assert coresys.resolution.issues[0].context is ContextType.DNS_SERVER assert coresys.resolution.issues[0].reference == "dns://192.168.30.1"
async def test_consumer_with_key_parameter(mocker: MockFixture, kafka_data_type, topic): msg = SampleMessage(value=b"5678", key=b"1234") f = AsyncMock() topic._add(f, {"key"}) await topic.message_handlers(msg) f.assert_called_once_with(key=b"1234")
async def test_process_callback_ignore_internal_state_no_counter(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, ) 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)), ) await switch.process(telegram) # no _context_task started because context_timeout is False assert switch._context_task is None async_after_update_callback.assert_called_once_with(switch) async_after_update_callback.reset_mock() # send same telegram again await switch.process(telegram) async_after_update_callback.assert_called_once_with(switch)
async def test_slash_command_on_activity_calls_callback(message_sent): listener_callback = AsyncMock() slash_command = SlashCommandActivity("/command", False, listener_callback) context = create_command_context(message_sent) await slash_command.on_activity(context) listener_callback.assert_called_once_with(context)
async def test_callback_group_addresses(self): """Test telegram_received_callback after state of switch was changed.""" xknx = XKNX() async_telegram_received_cb_one = AsyncMock() async_telegram_received_cb_two = AsyncMock() callback_one = xknx.telegram_queue.register_telegram_received_cb( async_telegram_received_cb_one, address_filters=[], group_addresses=[GroupAddress("1/2/3")], ) callback_two = xknx.telegram_queue.register_telegram_received_cb( async_telegram_received_cb_two, address_filters=[], group_addresses=[]) telegram = Telegram( destination_address=GroupAddress("1/2/3"), direction=TelegramDirection.INCOMING, payload=GroupValueWrite(DPTBinary(1)), ) await xknx.telegram_queue.process_telegram_incoming(telegram) async_telegram_received_cb_one.assert_called_once_with(telegram) async_telegram_received_cb_two.assert_not_called() async_telegram_received_cb_one.reset_mock() # modify the filters - add/remove a GroupAddress callback_one.group_addresses.remove(GroupAddress("1/2/3")) callback_two.group_addresses.append(GroupAddress("1/2/3")) await xknx.telegram_queue.process_telegram_incoming(telegram) async_telegram_received_cb_one.assert_not_called() async_telegram_received_cb_two.assert_called_once_with(telegram)
async def test_collect(self): """Test the collect method.""" mock_async_get_request = AsyncMock() mock_async_get_request.json.side_effect = [self.data_model, self.metrics] mocked_post = AsyncMock() mocked_post.return_value.close = Mock() with self.patched_get(mock_async_get_request): with patch("aiohttp.ClientSession.post", mocked_post): with self.assertRaises(RuntimeError): await quality_time_collector.collect() mocked_post.assert_called_once_with( self.measurement_api_url, json=dict( sources=[ dict( api_url=self.url, landing_url=self.url, value="42", total="84", entities=[], connection_error=None, parse_error=None, source_uuid="source_id", ) ], metric_uuid="metric_uuid", ), )
async def test_create_spelltable_link(self, bot: SpellBot, monkeypatch: pytest.MonkeyPatch): bot.mock_games = False generate_link_mock = AsyncMock(return_value="http://mock") monkeypatch.setattr(client, "generate_link", generate_link_mock) link = await bot.create_spelltable_link() assert link == "http://mock" generate_link_mock.assert_called_once_with()
async def test_on_message_no_guild(self, bot: SpellBot, monkeypatch: pytest.MonkeyPatch): super_on_message_mock = AsyncMock() monkeypatch.setattr(Bot, "on_message", super_on_message_mock) message = MagicMock() message.guild = None await bot.on_message(message) super_on_message_mock.assert_called_once_with(message)
def test_initial_tick(self): f = AsyncMock() timer = Timer(100, f) timer.start() self.assertFalse(timer.stopped) f.assert_called_once_with() timer.stop() self.assertTrue(timer.stopped)
async def test_multiple_message_handlers(mocker: MockFixture, kafka_data_type, topic): msg = SampleMessage(value=b"1234") mock_one = AsyncMock() mock_two = AsyncMock() topic._add(mock_one, {"value"}) topic._add(mock_two, {"value"}) await topic.message_handlers(msg) mock_one.assert_called_once_with(value=b"1234") mock_two.assert_called_once_with(value=b"1234")
async def test_register(self): """Test connection_state_changed after register.""" xknx = XKNX() async_connection_state_changed_cb = AsyncMock() xknx.connection_manager.register_connection_state_changed_cb( async_connection_state_changed_cb) await xknx.connection_manager.connection_state_changed( XknxConnectionState.CONNECTED) async_connection_state_changed_cb.assert_called_once_with( XknxConnectionState.CONNECTED)
def test_send_announcement(self): """Tests that Player.send_announcement() calls websocket send() """ websocket = MagicMock() send = AsyncMock() websocket.attach_mock(send, 'send') player = Player(None, websocket) asyncio.run(player.send_announcement("Breaking News!!!")) send.assert_called_once_with( '{"id": 1, "method": "announcement", "params": {"message": "Breaking News!!!"}}' )
async def test_register(self): """Test telegram_received_callback after state of switch was changed.""" xknx = XKNX() async_telegram_received_cb = AsyncMock() xknx.telegram_queue.register_telegram_received_cb(async_telegram_received_cb) telegram = Telegram( destination_address=GroupAddress("1/2/3"), direction=TelegramDirection.INCOMING, payload=GroupValueWrite(DPTBinary(1)), ) await xknx.telegram_queue.process_telegram_incoming(telegram) async_telegram_received_cb.assert_called_once_with(telegram)
async def test_update_device_config(hass, hass_client): """Test updating device config.""" with patch.object(config, "SECTIONS", ["group"]): await async_setup_component(hass, "config", {}) client = await hass_client() orig_data = { "hello.beer": { "ignored": True }, "other.entity": { "polling_intensity": 2 }, } def mock_read(path): """Mock reading data.""" return orig_data written = [] def mock_write(path, data): """Mock writing data.""" written.append(data) mock_call = AsyncMock() with patch("homeassistant.components.config._read", mock_read), patch( "homeassistant.components.config._write", mock_write), patch.object(hass.services, "async_call", mock_call): resp = await client.post( "/api/config/group/config/hello_beer", data=json.dumps({ "name": "Beer", "entities": ["light.top", "light.bottom"] }), ) await hass.async_block_till_done() assert resp.status == 200 result = await resp.json() assert result == {"result": "ok"} orig_data["hello_beer"]["name"] = "Beer" orig_data["hello_beer"]["entities"] = ["light.top", "light.bottom"] assert written[0] == orig_data mock_call.assert_called_once_with("group", "reload")
def test_abort_game(self): """Tests that abort_game() method calls handle_eliminated_players() once """ player = MagicMock() send_announcement = AsyncMock() player.attach_mock(send_announcement, 'send_announcement') game = GameSession(0, [player]) game.handle_eliminated_players = MagicMock() asyncio.run(game.abort_game()) game.handle_eliminated_players.assert_called_once() send_announcement.assert_called_once_with( MESSAGE_NETWORK_ERROR_OCCURRED)
def test_send_question(self): """Tests that Player.send_question() calls websocket send() """ question = Question('Question 1', ['A', 'B', 'C', 'D'], 'C') websocket = MagicMock() send = AsyncMock() websocket.attach_mock(send, 'send') player = Player(None, websocket) asyncio.run(player.send_question(question)) send.assert_called_once_with( '{"id": 1, "method": "ask_question", "params": {"question": "Question 1", "choices": ["A", "B", "C", "D"]}}' )
def test_ws_handler_impl_throws_exception(self): """Tests when ws_handler_impl() encounters exception thrown from the callback. It is expected to eat up the exception. """ callback = MagicMock() wss = WebsocketServer(64823, callback) handle_new_websocket = AsyncMock( side_effect=Exception("Error Occurred")) wss.callback.attach_mock(handle_new_websocket, 'handle_new_websocket') ws = MagicMock() asyncio.run(wss.ws_handler_impl(ws, None)) handle_new_websocket.assert_called_once_with(ws)
async def test_connected_event(self): """Test connected event callback.""" xknx = XKNX() async_connection_state_changed_cb = AsyncMock() xknx.connection_manager.register_connection_state_changed_cb( async_connection_state_changed_cb) assert not xknx.connection_manager.connected.is_set() await xknx.connection_manager.connection_state_changed( XknxConnectionState.CONNECTED) async_connection_state_changed_cb.assert_called_once_with( XknxConnectionState.CONNECTED) assert xknx.connection_manager.connected.is_set()
def test_player_send_json_rpc_request(self): """Tests that Player.send_json_rpc_request() calls websocket send() """ websocket = MagicMock() send = AsyncMock() websocket.attach_mock(send, 'send') player = Player(None, websocket) string = "Player is " + str([player]) params = dict() params['a'] = 'x' asyncio.run(player.send_json_rpc_request("general_request", params)) send.assert_called_once_with( '{"id": 1, "method": "general_request", "params": {"a": "x"}}')
def test_send_answers(self): """Tests that Player.send_answers() calls websocket send() """ question = Question('Question 1', ['A', 'B', 'C', 'D'], 'C') websocket = MagicMock() send = AsyncMock() websocket.attach_mock(send, 'send') player = Player(None, websocket) counts = [1, 0, 1, 0] asyncio.run(player.send_answers(question, counts)) send.assert_called_once_with( '{"id": 1, "method": "answers", "params": {"question": {"question": "Question 1", "choices": ["A", "B", "C", "D"], "answer": "C"}, "choice_counts": [1, 0, 1, 0]}}' )
async def test_git_clone(coresys: CoreSys, tmp_path: Path, clone_from: AsyncMock, branch: str | None): """Test git clone.""" fragment = f"#{branch}" if branch else "" repo = GitRepo(coresys, tmp_path, f"{REPO_URL}{fragment}") await repo.clone.__wrapped__(repo) kwargs = {"recursive": True, "depth": 1, "shallow-submodules": True} if branch: kwargs["branch"] = branch clone_from.assert_called_once_with( REPO_URL, str(tmp_path), **kwargs, )
async def test_process_to_callback(self, devices_process): """Test process_telegram_incoming with callback.""" 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)), ) await xknx.telegram_queue.process_telegram_incoming(telegram) async_telegram_received_callback.assert_called_once_with(telegram) devices_process.assert_called_once_with(telegram)
async def test_register_with_outgoing_telegrams(self): """Test telegram_received_callback with outgoing telegrams.""" xknx = XKNX() xknx.knxip_interface = AsyncMock() async_telegram_received_cb = AsyncMock() xknx.telegram_queue.register_telegram_received_cb( async_telegram_received_cb, None, None, True) telegram = Telegram( destination_address=GroupAddress("1/2/3"), direction=TelegramDirection.OUTGOING, payload=GroupValueWrite(DPTBinary(1)), ) await xknx.telegram_queue.process_telegram_outgoing(telegram) async_telegram_received_cb.assert_called_once_with(telegram)
async def test_update_config_write_to_temp_file(hass, hass_client, tmpdir): """Test config with a temp file.""" test_dir = await hass.async_add_executor_job(tmpdir.mkdir, "files") group_yaml = Path(test_dir / "group.yaml") with patch.object(group, "GROUP_CONFIG_PATH", group_yaml), patch.object( config, "SECTIONS", ["group"] ): await async_setup_component(hass, "config", {}) client = await hass_client() orig_data = { "hello.beer": {"ignored": True}, "other.entity": {"polling_intensity": 2}, } contents = dump(orig_data) await hass.async_add_executor_job(write_utf8_file, group_yaml, contents) mock_call = AsyncMock() with patch.object(hass.services, "async_call", mock_call): resp = await client.post( "/api/config/group/config/hello_beer", data=json.dumps( {"name": "Beer", "entities": ["light.top", "light.bottom"]} ), ) await hass.async_block_till_done() assert resp.status == HTTPStatus.OK result = await resp.json() assert result == {"result": "ok"} new_data = await hass.async_add_executor_job(load_yaml, group_yaml) assert new_data == { **orig_data, "hello_beer": { "name": "Beer", "entities": ["light.top", "light.bottom"], }, } mock_call.assert_called_once_with("group", "reload")
def test_ws_handler_impl(self): """Tests whether ws_handler_impl() calls callback with correct arguments """ callback = MagicMock() wss = WebsocketServer(64823, callback) handle_new_websocket = AsyncMock() wss.callback.attach_mock(handle_new_websocket, 'handle_new_websocket') ws = MagicMock() asyncio.run(wss.ws_handler_impl(ws, None)) handle_new_websocket.assert_called_once_with(ws) # Sanity check the WebsocketCallbackInterface as well. wsci = WebsocketCallbackInterface() wsci.handle_new_websocket(None) wss = WebsocketServer(64823, wsci) asyncio.run(wss.ws_handler_impl(ws, None))
async def _async_test_service( service, data, method, payload=None, domain=DOMAIN, failure_side_effect=BulbException, ): err_count = len( [x for x in caplog.records if x.levelno == logging.ERROR]) # success if method.startswith("async_"): mocked_method = AsyncMock() else: mocked_method = MagicMock() setattr(mocked_bulb, method, mocked_method) await hass.services.async_call(domain, service, data, blocking=True) if payload is None: mocked_method.assert_called_once() elif type(payload) == list: mocked_method.assert_called_once_with(*payload) else: mocked_method.assert_called_once_with(**payload) assert (len([x for x in caplog.records if x.levelno == logging.ERROR]) == err_count) # failure if failure_side_effect: if method.startswith("async_"): mocked_method = AsyncMock(side_effect=failure_side_effect) else: mocked_method = MagicMock(side_effect=failure_side_effect) setattr(mocked_bulb, method, mocked_method) await hass.services.async_call(domain, service, data, blocking=True) assert (len([ x for x in caplog.records if x.levelno == logging.ERROR ]) == err_count + 1)
async def test_approve(coresys: CoreSys, dns_query: AsyncMock): """Test approve existing DNS Server failure issues.""" dns_server_failures = CheckDNSServerFailures(coresys) coresys.core.state = CoreState.RUNNING assert dns_server_failures.dns_servers == ["dns://192.168.30.1"] dns_query.side_effect = DNSError() assert await dns_server_failures.approve_check(reference="dns://1.1.1.1" ) is False dns_query.assert_not_called() assert (await dns_server_failures.approve_check( reference="dns://192.168.30.1") is True) dns_query.assert_called_once_with("_checkdns.home-assistant.io", "A") dns_query.reset_mock() dns_query.side_effect = None assert (await dns_server_failures.approve_check( reference="dns://192.168.30.1") is False) dns_query.assert_called_once_with("_checkdns.home-assistant.io", "A")
async def test_approve(coresys: CoreSys, dns_query: AsyncMock): """Test approve existing DNS Server IPv6 error issues.""" dns_server_ipv6_errors = CheckDNSServerIPv6Errors(coresys) coresys.core.state = CoreState.RUNNING assert dns_server_ipv6_errors.dns_servers == ["dns://192.168.30.1"] dns_query.side_effect = DNSError(4, "Domain name not found") assert (await dns_server_ipv6_errors.approve_check( reference="dns://1.1.1.1") is False) dns_query.assert_not_called() assert (await dns_server_ipv6_errors.approve_check( reference="dns://192.168.30.1") is True) dns_query.assert_called_once_with("_checkdns.home-assistant.io", "AAAA") dns_query.reset_mock() dns_query.side_effect = DNSError( 1, "DNS server returned answer with no data") assert (await dns_server_ipv6_errors.approve_check( reference="dns://192.168.30.1") is False) dns_query.assert_called_once_with("_checkdns.home-assistant.io", "AAAA") dns_query.reset_mock() dns_query.side_effect = None assert (await dns_server_ipv6_errors.approve_check( reference="dns://192.168.30.1") is False) dns_query.assert_called_once_with("_checkdns.home-assistant.io", "AAAA")
async def test_callback_raising(self, logging_exception_mock): """Test telegram_received_callback raising an exception.""" xknx = XKNX() good_callback_1 = AsyncMock() bad_callback = AsyncMock(side_effect=Exception("Boom")) good_callback_2 = AsyncMock() xknx.telegram_queue.register_telegram_received_cb(good_callback_1) xknx.telegram_queue.register_telegram_received_cb(bad_callback) xknx.telegram_queue.register_telegram_received_cb(good_callback_2) telegram = Telegram( destination_address=GroupAddress("1/2/3"), direction=TelegramDirection.INCOMING, payload=GroupValueWrite(DPTBinary(1)), ) await xknx.telegram_queue.process_telegram_incoming(telegram) good_callback_1.assert_called_once_with(telegram) bad_callback.assert_called_once_with(telegram) good_callback_2.assert_called_once_with(telegram) logging_exception_mock.assert_called_once_with( "Unexpected error while processing telegram_received_cb for %s", telegram, )