async def test_button(hass, aioclient_mock, qs_devices): """Test that buttons fire an event.""" async def get_devices_json(method, url, data): return AiohttpClientMockResponse(method=method, url=url, json=qs_devices) config = {"qwikswitch": {"button_events": "TOGGLE"}} aioclient_mock.get("http://127.0.0.1:2020/&device", side_effect=get_devices_json) listen_mock = MockLongPollSideEffect() aioclient_mock.get("http://127.0.0.1:2020/&listen", side_effect=listen_mock) assert await async_setup_component(hass, QWIKSWITCH, config) await hass.async_start() await hass.async_block_till_done() button_pressed = Mock() hass.bus.async_listen_once("qwikswitch.button.@a00002", button_pressed) listen_mock.queue_response(json={"id": "@a00002", "cmd": "TOGGLE"}, ) await asyncio.sleep(0.01) await hass.async_block_till_done() button_pressed.assert_called_once() listen_mock.stop()
async def test_app_middleware_with_handlers(self): mock = Mock() class Middleware(BaseMiddleware): async def do(self, r, h, a): mock(r, h, a) return await h(r) @Middleware(self.resolver) class App(jj.App): resolver = self.resolver @MethodMatcher(resolver, "*") async def handler(request): return Response(status=200) app = App() async with run(app) as client: response = await client.get("/") self.assertEqual(response.status, 200) mock.assert_called_once() request_arg, handler_arg, app_arg = mock.call_args[0] self.assertIsInstance(request_arg, Request) self.assertEqual(handler_arg, App.handler) self.assertEqual(app_arg, app)
async def test_callbacks(): """Test detection and handling of both sync and async callbacks.""" callback = Mock() async_callback = CoroutineMock() with patch("pysqueezebox.discovery._unpack_discovery_response", return_value=RESPONSE): protocol = pysqueezebox.discovery.ServerDiscoveryProtocol(callback) async_protocol = pysqueezebox.discovery.ServerDiscoveryProtocol( async_callback) protocol.datagram_received(ADDR, DATA) async_protocol.datagram_received(ADDR, DATA) callback.assert_called_once() async_callback.assert_called_once()
async def test_middleware_with_handler(self): mock = Mock() class App(jj.App): resolver = self.resolver @MethodMatcher(resolver, "*") async def handler(request): mock(request) return Response(status=200) middleware = SelfMiddleware(self.resolver) async with run(App(), middlewares=[middleware]) as client: response = await client.get("/") self.assertEqual(response.status, 200) mock.assert_called_once() request_arg, = mock.call_args[0] self.assertIsInstance(request_arg, Request)
async def test_update_device(hass): """Test that update works.""" host = "1.2.3.4" entry = MockConfigEntry(domain=dynalite.DOMAIN, data={dynalite.CONF_HOST: host}) entry.add_to_hass(hass) with patch("homeassistant.components.dynalite.bridge.DynaliteDevices" ) as mock_dyn_dev: mock_dyn_dev().async_setup = CoroutineMock(return_value=True) assert await hass.config_entries.async_setup(entry.entry_id) # Not waiting so it add the devices before registration update_device_func = mock_dyn_dev.mock_calls[1][2][ "update_device_func"] device = Mock() device.unique_id = "abcdef" wide_func = Mock() async_dispatcher_connect(hass, f"dynalite-update-{host}", wide_func) specific_func = Mock() async_dispatcher_connect(hass, f"dynalite-update-{host}-{device.unique_id}", specific_func) update_device_func(CONF_ALL) await hass.async_block_till_done() wide_func.assert_called_once() specific_func.assert_not_called() update_device_func(device) await hass.async_block_till_done() wide_func.assert_called_once() specific_func.assert_called_once()
async def test_app_middleware_without_handlers(self): mock = Mock() class Middleware(BaseMiddleware): async def do(self, request, handler, app): mock(request, handler, app) return await handler(request) @Middleware(self.resolver) class App(jj.App): resolver = self.resolver app = App() async with run(app) as client: response = await client.get("/") self.assertEqual(response.status, 404) mock.assert_called_once() request_arg, handler_arg, app_arg = mock.call_args[0] self.assertIsInstance(request_arg, Request) self.assertEqual(handler_arg, default_handler) self.assertEqual(app_arg, app)
class MockGateway: """Class to mock a TCP gateway.""" def __init__(self, request, message_delay_zero): """Initialize the class.""" request.addfinalizer(self.fin) self.reader = None self.writer = None self.server = None self.in_buffer = bytearray() self.new_dev_func = Mock() self.update_dev_func = Mock() self.exceptions = [] if message_delay_zero: with patch("dynalite_devices_lib.dynalite.MESSAGE_DELAY", 0): self.dyn_dev = DynaliteDevices( new_device_func=self.new_dev_func, update_device_func=self.update_dev_func, ) else: self.dyn_dev = DynaliteDevices( new_device_func=self.new_dev_func, update_device_func=self.update_dev_func, ) async def run_server(self): """Run the actual server.""" async def handle_connection(reader, writer): """Run a single session. Assumes only one for tests.""" assert not self.reader and not self.writer self.reader = reader self.writer = writer while not reader.at_eof(): data = await reader.read(100) addr = writer.get_extra_info("peername") dyn_const.LOGGER.debug("Received message from %s - %s", addr, [int(byte) for byte in data]) for byte in data: self.in_buffer.append(byte) self.reader = self.writer = None self.server = await asyncio.start_server(handle_connection, "127.0.0.1", 12345) addr = self.server.sockets[0].getsockname() dyn_const.LOGGER.debug("Serving on %s", addr) async with self.server: await self.server.serve_forever() async def async_setup_server(self): """Start the server.""" def exc_handle(loop, context): """Handle exceptions by rethrowing them, which will fail the test.""" self.exceptions.append(context["exception"]) asyncio.get_event_loop().set_exception_handler(exc_handle) asyncio.create_task(self.run_server()) await asyncio.sleep(0.01) async def check_writes(self, packets): """Check that a set of packets was written.""" await asyncio.sleep(0.01) assert len(self.in_buffer) == len(packets) * 8 received = [ self.in_buffer[i * 8:i * 8 + 8] for i in range(0, len(packets)) ] for packet in packets: assert packet.msg in received self.reset() async def check_single_write(self, packet): """Check that there was only a single packet written.""" await self.check_writes([packet]) async def receive_message(self, message): """Fake a received message.""" self.writer.write(message) await self.writer.drain() await asyncio.sleep(0.01) async def receive(self, packet): """Fake a received packet.""" await self.receive_message(packet.msg) def configure_dyn_dev(self, config, num_devices=1): """Configure the DynaliteDevices.""" self.new_dev_func.reset_mock() self.dyn_dev.configure(config) if num_devices == 0: self.new_dev_func.assert_not_called() return None self.new_dev_func.assert_called_once() assert len(self.new_dev_func.mock_calls[0][1][0]) == num_devices return self.new_dev_func.mock_calls[0][1][0] async def async_setup_dyn_dev(self): """Set up the internal DynaliteDevices.""" return await self.dyn_dev.async_setup() def reset(self): """Reset the in buffer.""" self.in_buffer = bytearray() def reset_connection(self): """Reset the current connection.""" if self.writer: self.writer.close() async def shutdown(self): """Shut down the server.""" self.reset_connection() self.server.close() await self.server.wait_closed() async def async_fin(self): """Shut the gateway down.""" await self.shutdown() await self.dyn_dev.async_reset() def fin(self): """Run shutdown async.""" asyncio.get_event_loop().run_until_complete(self.async_fin()) for ex in self.exceptions: raise ex