async def test_check_connection(app, client, mocker): s = spark.fget(app) await s.check_connection() m_wait_sync = mocker.patch(TESTED + '.service_status.wait_synchronized', AsyncMock()) m_wait_sync.return_value = False m_cmder = Mock() m_cmder.execute = AsyncMock() m_cmder.start_reconnect = AsyncMock() mocker.patch(TESTED + '.commander.fget').return_value = m_cmder await s.check_connection() assert m_cmder.execute.await_count == 0 assert m_cmder.start_reconnect.await_count == 0 m_wait_sync.return_value = True await s.check_connection() assert m_cmder.execute.await_count == 1 assert m_cmder.start_reconnect.await_count == 0 m_cmder.execute.side_effect = exceptions.CommandException() await s.check_connection() assert m_cmder.execute.await_count == 2 assert m_cmder.start_reconnect.await_count == 1
async def set_display_settings(self): if not service_status.desc(self.app).is_acknowledged: return store = global_store.fget(self.app) controller = spark.fget(self.app) write_required = False display_block = await controller.read_object({ 'nid': const.DISPLAY_SETTINGS_NID }) user_unit = store.units['temperature'] expected_unit = 'TEMP_FAHRENHEIT' if user_unit == 'degF' else 'TEMP_CELSIUS' block_unit = display_block['data']['tempUnit'] if expected_unit != block_unit: write_required = True display_block['data']['tempUnit'] = expected_unit LOGGER.info(f'Spark display temperature unit set to {user_unit}') user_tz_name = store.time_zone['name'] user_tz = store.time_zone['posixValue'] block_tz = display_block['data']['timeZone'] if user_tz != block_tz: write_required = True display_block['data']['timeZone'] = user_tz LOGGER.info(f'Spark display time zone set to {user_tz} ({user_tz_name})') if write_required: await controller.write_object(display_block)
async def test_write_error(app, client, syncher, mocker): mocker.patch.object(spark.fget(app), 'write_object', AsyncMock(side_effect=RuntimeError)) await disconnect(app) with pytest.raises(RuntimeError): await connect(app, syncher) assert states(app) == [False, True, False]
def test_main(mocker, app): mocker.patch(TESTED + '.service.run') mocker.patch(TESTED + '.service.create_app').return_value = app main.main() assert None not in [ commander.fget(app), config_store.fget(app), block_store.fget(app), spark.fget(app), mqtt.handler(app), broadcaster.fget(app) ]
async def test_list_transcoding(app, client, store, mocker): s = spark.fget(app) obj_type, obj_data = generate_obj() ids = {f'obj{i}' for i in range(5)} for i, id in enumerate(ids): store[id, 300+i] = dict() await s.create_object({ 'id': id, 'groups': [0], 'type': obj_type, 'data': obj_data }) retval = await s.list_stored_objects() assert ids.issubset({obj['id'] for obj in retval['objects']})
async def test_timeout(app, client, syncher, mocker): async def m_wait_ack(app, wait=True): if wait: await asyncio.sleep(1) return False await disconnect(app) await syncher.end() mocker.patch(TESTED + '.HANDSHAKE_TIMEOUT_S', 0.1) mocker.patch(TESTED + '.PING_INTERVAL_S', 0.0001) mocker.patch(TESTED + '.service_status.wait_acknowledged', side_effect=m_wait_ack) mocker.patch.object(spark.fget(app), 'noop', AsyncMock(side_effect=RuntimeError)) service_status.set_connected(app, 'timeout test') with pytest.raises(asyncio.TimeoutError): await syncher.run()
async def test_transcoding(app, client, store): s = spark.fget(app) c = codec.fget(app) obj_type, obj_data = generate_obj() enc_type, enc_data = await c.encode(obj_type, obj_data) object_args = { 'id': 'alias', 'groups': [1], 'type': obj_type, 'data': obj_data } store['alias', 300] = dict() c.encode = AsyncMock(wraps=c.encode) c.decode = AsyncMock(wraps=c.decode) retval = await s.create_object(object_args) assert retval['data']['settings']['address'] == 'ff'.rjust(16, '0') c.encode.assert_any_await(obj_type, obj_data) c.decode.assert_any_await(enc_type, enc_data, opts=DecodeOpts())
def __init__(self, app: web.Application): self.app = app self._spark = spark.fget(app) self._store = block_store.fget(app) self._publish_changed = True
async def do_command(request: web.Request) -> web.Response: command = request['data']['command'] data = request['data']['data'] func = getattr(spark.fget(request.app), command) return web.json_response(await func(**data))