async def test_init_api_mode(api, monkeypatch):
monkeypatch.setattr(api._uart, "baudrate", 57600)
api.enter_at_command_mode = mock.AsyncMock(return_value=True)
res = await api.init_api_mode()
assert res is None
assert api.enter_at_command_mode.call_count == 1
api.enter_at_command_mode = mock.AsyncMock(return_value=False)
res = await api.init_api_mode()
assert res is False
assert api.enter_at_command_mode.call_count == 10
async def enter_at_mode():
if api._uart.baudrate == 9600:
return True
return False
api._uart.baudrate = 57600
api.enter_at_command_mode = mock.MagicMock(side_effect=enter_at_mode)
api.api_mode_at_commands = mock.AsyncMock(return_value=True)
res = await api.init_api_mode()
assert res is True
assert api.enter_at_command_mode.call_count == 5
async def _test_start_network(
app,
ai_status=0xFF,
api_mode=True,
api_config_succeeds=True,
ee=1,
eo=2,
zs=2,
legacy_module=False,
):
ai_tries = 5
app.state.node_info.nwk = mock.sentinel.nwk
def _at_command_mock(cmd, *args):
nonlocal ai_tries
if not api_mode:
raise asyncio.TimeoutError
if cmd == "CE" and legacy_module:
raise RuntimeError
ai_tries -= 1 if cmd == "AI" else 0
return {
"AI": ai_status if ai_tries < 0 else 0xFF,
"CE": 1 if ai_status == 0 else 0,
"EO": eo,
"EE": ee,
"ID": 0x25DCF87E03EA5906,
"MY": 0xFFFE if ai_status else 0x0000,
"NJ": mock.sentinel.at_nj,
"OI": 0xDD94,
"OP": mock.sentinel.at_op,
"SH": 0x08070605,
"SL": 0x04030201,
"ZS": zs,
}.get(cmd, None)
def init_api_mode_mock():
nonlocal api_mode
api_mode = api_config_succeeds
return api_config_succeeds
with mock.patch("zigpy_xbee.api.XBee") as XBee_mock:
api_mock = mock.MagicMock()
api_mock._at_command = mock.AsyncMock(side_effect=_at_command_mock)
api_mock.init_api_mode = mock.AsyncMock(side_effect=init_api_mode_mock)
XBee_mock.new = mock.AsyncMock(return_value=api_mock)
await app.connect()
app.form_network = mock.AsyncMock()
await app.load_network_info()
await app.start_network()
return app
async def test_get_association_state(app):
ai_results = (0xFF, 0xFF, 0xFF, 0xFF, mock.sentinel.ai)
app._api._at_command = mock.AsyncMock(
spec=XBee._at_command,
side_effect=ai_results,
)
ai = await app._get_association_state()
assert app._api._at_command.call_count == len(ai_results)
assert ai is mock.sentinel.ai
def app(monkeypatch):
monkeypatch.setattr(application, "TIMEOUT_TX_STATUS", 0.1)
monkeypatch.setattr(application, "TIMEOUT_REPLY", 0.1)
monkeypatch.setattr(application, "TIMEOUT_REPLY_EXTENDED", 0.1)
app = application.ControllerApplication(APP_CONFIG)
api = XBee(APP_CONFIG[config.CONF_DEVICE])
monkeypatch.setattr(api, "_command", mock.AsyncMock())
app._api = api
app.state.node_info.nwk = 0x0000
app.state.node_info.ieee = t.EUI64.convert("aa:bb:cc:dd:ee:ff:00:11")
return app
async def test_api_mode_at_commands(api):
api.command_mode_at_cmd = mock.AsyncMock(
return_value=mock.sentinel.api_mode)
res = await api.api_mode_at_commands(57600)
assert res is True
async def mock_at_cmd(cmd):
if cmd == "ATWR\r":
return False
return True
api.command_mode_at_cmd = mock_at_cmd
res = await api.api_mode_at_commands(57600)
assert res is None
async def test_reconnect_multiple_disconnects(monkeypatch, caplog):
api = xbee_api.XBee(DEVICE_CONFIG)
connect_mock = mock.AsyncMock(return_value=True)
monkeypatch.setattr(uart, "connect", connect_mock)
await api.connect()
caplog.set_level(logging.DEBUG)
connect_mock.reset_mock()
connect_mock.side_effect = [OSError, mock.sentinel.uart_reconnect]
api.connection_lost("connection lost")
await asyncio.sleep(0.3)
api.connection_lost("connection lost 2")
await asyncio.sleep(0.3)
assert "Cancelling reconnection attempt" in caplog.messages
assert api._uart is mock.sentinel.uart_reconnect
assert connect_mock.call_count == 2
async def test_form_network(app):
legacy_module = False
async def mock_at_command(cmd, *args):
if cmd == "MY":
return 0x0000
elif cmd == "WR":
app._api.coordinator_started_event.set()
elif cmd == "CE" and legacy_module:
raise RuntimeError
return None
app._api._at_command = mock.MagicMock(spec=XBee._at_command,
side_effect=mock_at_command)
app._api._queued_at = mock.MagicMock(spec=XBee._at_command,
side_effect=mock_at_command)
app._get_association_state = mock.AsyncMock(
spec=application.ControllerApplication._get_association_state,
return_value=0x00,
)
app.write_network_info = mock.MagicMock(wraps=app.write_network_info)
await app.form_network()
assert app._api._at_command.call_count >= 1
assert app._api._queued_at.call_count >= 7
network_info = app.write_network_info.mock_calls[0][2]["network_info"]
app._api._queued_at.assert_any_call("SC", 1 << (network_info.channel - 11))
app._api._queued_at.assert_any_call("KY", b"ZigBeeAlliance09")
app._api._at_command.reset_mock()
app._api._queued_at.reset_mock()
legacy_module = True
await app.form_network()
assert app._api._at_command.call_count >= 1
assert app._api._queued_at.call_count >= 7
network_info = app.write_network_info.mock_calls[0][2]["network_info"]
app._api._queued_at.assert_any_call("SC", 1 << (network_info.channel - 11))
app._api._queued_at.assert_any_call("KY", b"ZigBeeAlliance09")
async def test_reconnect_multiple_attempts(monkeypatch, caplog):
api = xbee_api.XBee(DEVICE_CONFIG)
connect_mock = mock.AsyncMock(return_value=True)
monkeypatch.setattr(uart, "connect", connect_mock)
await api.connect()
caplog.set_level(logging.DEBUG)
connect_mock.reset_mock()
connect_mock.side_effect = [
asyncio.TimeoutError,
OSError,
mock.sentinel.uart_reconnect,
]
with mock.patch("asyncio.sleep"):
api.connection_lost("connection lost")
await api._conn_lost_task
assert api._uart is mock.sentinel.uart_reconnect
assert connect_mock.call_count == 3
async def test_permit(app):
app._api._at_command = mock.AsyncMock()
time_s = 30
await app.permit_ncp(time_s)
assert app._api._at_command.call_count == 2
assert app._api._at_command.call_args_list[0][0][1] == time_s
async def test_enter_at_command_mode(api):
api.command_mode_at_cmd = mock.AsyncMock(
return_value=mock.sentinel.at_response)
res = await api.enter_at_command_mode()
assert res == mock.sentinel.at_response
async def test_connect(monkeypatch):
api = xbee_api.XBee(DEVICE_CONFIG)
monkeypatch.setattr(uart, "connect", mock.AsyncMock())
await api.connect()
