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
