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))
