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()
class TestValidateDecoratorTestCase(TestCase): def setUp(self): self.dummy_func = Mock() self.self_dummy = Mock( request=Mock(), _schemas={ "post": Schema( {"job_id": Coerce(int), "email": Email(), "template": str} ) }, ) def test_validation_passed(self): self.self_dummy.request.method = "POST" self.self_dummy.request.body = ( b'{"job_id": 12, "email": "*****@*****.**", "template": "Hello!"}' ) validate_json(self.dummy_func)(self.self_dummy) self.dummy_func.assert_called_once_with( self.self_dummy, {"job_id": 12, "email": "*****@*****.**", "template": "Hello!"}, ) def test_validation_invalid(self): self.self_dummy.request.method = "POST" self.self_dummy.request.body = ( b'{"job_id": "test", "email": "*****@*****.**", "template": "Hello!"}' ) with self.assertRaises(ValidationError): validate_json(self.dummy_func)(self.self_dummy) self.dummy_func.assert_not_called() def test_schema_not_found(self): self.self_dummy.request.method = "PUT" self.self_dummy.request.body = ( b'{"job_id": 12, "email": "*****@*****.**", "template": "Hello!"}' ) with self.assertRaises(ValidationError): validate_json(self.dummy_func)(self.self_dummy) self.dummy_func.assert_not_called() def test_invalid_json(self): self.self_dummy.request.method = "POST" self.self_dummy.request.body = b"Hello" with self.assertRaises(UnsupportedFormatError): validate_json(self.dummy_func)(self.self_dummy) self.dummy_func.assert_not_called()
def test_maybe_init_is_not_main(cli_mock: Mock) -> None: """Test cli not called when file is not main.""" cli_module.maybe_init() cli_mock.assert_not_called()
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