def test_disconnect_response(self):
"""Test string representation of KNX/IP DisconnectResponse."""
disconnect_response = DisconnectResponse()
disconnect_response.communication_channel_id = 23
assert (
str(disconnect_response) ==
'<DisconnectResponse communication_channel_id="23" status_code="ErrorCode.E_NO_ERROR" />'
)
def test_disconnect_response(self):
"""Test string representation of KNX/IP DisconnectResponse."""
xknx = XKNX(loop=self.loop)
disconnect_response = DisconnectResponse(xknx)
disconnect_response.communication_channel_id = 23
self.assertEqual(
str(disconnect_response),
'<DisconnectResponse CommunicationChannelID="23" status_code="ErrorCode.E_NO_ERROR" />')
def test_disconnect_response(self):
"""Test string representation of KNX/IP DisconnectResponse."""
xknx = XKNX(loop=self.loop)
disconnect_response = DisconnectResponse(xknx)
disconnect_response.communication_channel_id = 23
self.assertEqual(
str(disconnect_response),
'<DisconnectResponse CommunicationChannelID="23" status_code="ErrorCode.E_NO_ERROR" />')
def _disconnect_request_received(
self, disconnect_request: DisconnectRequest) -> None:
"""Handle incoming disconnect request."""
logger.warning("Received DisconnectRequest from tunnelling sever.")
# We should not receive DisconnectRequest for other communication_channels
# If we do we close our communication_channel before reconnection.
if disconnect_request.communication_channel_id == self.communication_channel:
disconnect_response = DisconnectResponse(
communication_channel_id=self.communication_channel, )
self.transport.send(KNXIPFrame.init_from_body(disconnect_response))
self.communication_channel = None
self._tunnel_lost()
def test_disconnect_response(self):
"""Test parsing and streaming DisconnectResponse KNX/IP packet."""
raw = bytes((0x06, 0x10, 0x02, 0x0A, 0x00, 0x08, 0x15, 0x25))
knxipframe = KNXIPFrame()
knxipframe.from_knx(raw)
assert isinstance(knxipframe.body, DisconnectResponse)
assert knxipframe.body.communication_channel_id == 21
assert knxipframe.body.status_code == ErrorCode.E_NO_MORE_UNIQUE_CONNECTIONS
disconnect_response = DisconnectResponse(
communication_channel_id=21,
status_code=ErrorCode.E_NO_MORE_UNIQUE_CONNECTIONS,
)
knxipframe2 = KNXIPFrame.init_from_body(disconnect_response)
assert knxipframe2.to_knx() == raw
def test_disconnect_response(self):
"""Test parsing and streaming DisconnectResponse KNX/IP packet."""
raw = (0x06, 0x10, 0x02, 0x0A, 0x00, 0x08, 0x15, 0x25)
xknx = XKNX()
knxipframe = KNXIPFrame(xknx)
knxipframe.from_knx(raw)
self.assertTrue(isinstance(knxipframe.body, DisconnectResponse))
self.assertEqual(knxipframe.body.communication_channel_id, 21)
self.assertEqual(
knxipframe.body.status_code, ErrorCode.E_NO_MORE_UNIQUE_CONNECTIONS
)
disconnect_response = DisconnectResponse(
xknx,
communication_channel_id=21,
status_code=ErrorCode.E_NO_MORE_UNIQUE_CONNECTIONS,
)
knxipframe2 = KNXIPFrame.init_from_body(disconnect_response)
self.assertEqual(knxipframe2.to_knx(), list(raw))
async def test_tunnel_connect_send_disconnect(
self, time_travel, route_back, data_endpoint_addr, local_endpoint
):
"""Test initiating a tunnelling connection."""
local_addr = ("192.168.1.1", 12345)
remote_addr = ("192.168.1.2", 3671)
self.tunnel.route_back = route_back
gateway_data_endpoint = (
HPAI(*data_endpoint_addr) if data_endpoint_addr else HPAI()
)
self.tunnel.transport.connect = AsyncMock()
self.tunnel.transport.getsockname = Mock(return_value=local_addr)
self.tunnel.transport.send = Mock()
self.tunnel.transport.stop = Mock()
# Connect
connect_request = ConnectRequest(
control_endpoint=local_endpoint,
data_endpoint=local_endpoint,
)
connect_frame = KNXIPFrame.init_from_body(connect_request)
connection_task = asyncio.create_task(self.tunnel.connect())
await time_travel(0)
self.tunnel.transport.connect.assert_called_once()
self.tunnel.transport.send.assert_called_once_with(connect_frame)
connect_response_frame = KNXIPFrame.init_from_body(
ConnectResponse(
communication_channel=23,
data_endpoint=gateway_data_endpoint,
identifier=7,
)
)
self.tunnel.transport.handle_knxipframe(connect_response_frame, remote_addr)
await connection_task
assert self.tunnel._data_endpoint_addr == data_endpoint_addr
assert self.tunnel._src_address == IndividualAddress(7)
# Send - use data endpoint
self.tunnel.transport.send.reset_mock()
test_telegram = Telegram(payload=GroupValueWrite(DPTArray((1,))))
test_telegram_frame = KNXIPFrame.init_from_body(
TunnellingRequest(
communication_channel_id=23,
sequence_counter=0,
cemi=CEMIFrame.init_from_telegram(
test_telegram,
code=CEMIMessageCode.L_DATA_REQ,
src_addr=IndividualAddress(7),
),
)
)
asyncio.create_task(self.tunnel.send_telegram(test_telegram))
await time_travel(0)
self.tunnel.transport.send.assert_called_once_with(
test_telegram_frame, addr=data_endpoint_addr
)
# skip ack and confirmation
# Disconnect
self.tunnel.transport.send.reset_mock()
disconnect_request = DisconnectRequest(
communication_channel_id=23,
control_endpoint=local_endpoint,
)
disconnect_frame = KNXIPFrame.init_from_body(disconnect_request)
disconnection_task = asyncio.create_task(self.tunnel.disconnect())
await time_travel(0)
self.tunnel.transport.send.assert_called_once_with(disconnect_frame)
disconnect_response_frame = KNXIPFrame.init_from_body(
DisconnectResponse(communication_channel_id=23)
)
self.tunnel.transport.handle_knxipframe(disconnect_response_frame, remote_addr)
await disconnection_task
assert self.tunnel._data_endpoint_addr is None
self.tunnel.transport.stop.assert_called_once()
