async def test_last_msg_time(monkeypatch):
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory()
async with alice_multiplexer.multiplex():
async with bob_multiplexer.multiplex():
assert alice_multiplexer.last_msg_time == 0
assert bob_multiplexer.last_msg_time == 0
alice_stream = alice_multiplexer.stream_protocol_messages(
P2PProtocolV5)
bob_stream = bob_multiplexer.stream_protocol_messages(
P2PProtocolV5)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(
P2PProtocolV5)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(
P2PProtocolV5)
now = time.monotonic()
monkeypatch.setattr(time, 'monotonic', lambda: now)
alice_p2p_protocol.send(Ping(None))
cmd = await asyncio.wait_for(bob_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Ping)
assert bob_multiplexer.last_msg_time == now
bob_p2p_protocol.send(Pong(None))
cmd = await asyncio.wait_for(alice_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Pong)
assert alice_multiplexer.last_msg_time == now
async def test_multiplexer_p2p_and_paragon_protocol():
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory(
protocol_types=(SecondProtocol, ), )
async with alice_multiplexer.multiplex():
async with bob_multiplexer.multiplex():
alice_p2p_stream = alice_multiplexer.stream_protocol_messages(
P2PProtocolV5)
bob_p2p_stream = bob_multiplexer.stream_protocol_messages(
P2PProtocolV5)
alice_second_stream = alice_multiplexer.stream_protocol_messages(
SecondProtocol)
bob_second_stream = bob_multiplexer.stream_protocol_messages(
SecondProtocol)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(
P2PProtocolV5)
alice_second_protocol = alice_multiplexer.get_protocol_by_type(
SecondProtocol)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(
P2PProtocolV5)
bob_second_protocol = bob_multiplexer.get_protocol_by_type(
SecondProtocol)
alice_second_protocol.send(CommandA(None))
alice_p2p_protocol.send(Ping(None))
alice_second_protocol.send(CommandB(None))
cmd = await asyncio.wait_for(bob_p2p_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Ping)
bob_second_protocol.send(CommandA(None))
bob_p2p_protocol.send(Pong(None))
bob_second_protocol.send(CommandB(None))
cmd = await asyncio.wait_for(alice_p2p_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Pong)
cmd_1 = await asyncio.wait_for(bob_second_stream.asend(None),
timeout=DEFAULT_TIMEOUT
) # noqa: E501
cmd_2 = await asyncio.wait_for(bob_second_stream.asend(None),
timeout=DEFAULT_TIMEOUT
) # noqa: E501
cmd_3 = await asyncio.wait_for(alice_second_stream.asend(None),
timeout=DEFAULT_TIMEOUT
) # noqa: E501
cmd_4 = await asyncio.wait_for(alice_second_stream.asend(None),
timeout=DEFAULT_TIMEOUT
) # noqa: E501
assert isinstance(cmd_1, CommandA)
assert isinstance(cmd_2, CommandB)
assert isinstance(cmd_3, CommandA)
assert isinstance(cmd_4, CommandB)
async def test_multiplexer_p2p_and_two_more_protocols():
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory(
protocol_types=(SecondProtocol, ThirdProtocol),
)
async with alice_multiplexer.multiplex():
async with bob_multiplexer.multiplex():
alice_p2p_stream = alice_multiplexer.stream_protocol_messages(P2PProtocolV5)
bob_p2p_stream = bob_multiplexer.stream_protocol_messages(P2PProtocolV5)
alice_second_stream = alice_multiplexer.stream_protocol_messages(SecondProtocol)
bob_second_stream = bob_multiplexer.stream_protocol_messages(SecondProtocol)
alice_third_stream = alice_multiplexer.stream_protocol_messages(ThirdProtocol)
bob_third_stream = bob_multiplexer.stream_protocol_messages(ThirdProtocol)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(P2PProtocolV5)
alice_second_protocol = alice_multiplexer.get_protocol_by_type(SecondProtocol)
alice_third_protocol = alice_multiplexer.get_protocol_by_type(ThirdProtocol)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(P2PProtocolV5)
bob_second_protocol = bob_multiplexer.get_protocol_by_type(SecondProtocol)
bob_third_protocol = bob_multiplexer.get_protocol_by_type(ThirdProtocol)
alice_second_protocol.send_cmd(CommandA)
alice_third_protocol.send_cmd(CommandC)
alice_p2p_protocol.send_ping()
alice_second_protocol.send_cmd(CommandB)
alice_third_protocol.send_cmd(CommandD)
cmd, _ = await asyncio.wait_for(bob_p2p_stream.asend(None), timeout=0.1)
assert isinstance(cmd, Ping)
bob_second_protocol.send_cmd(CommandA)
bob_third_protocol.send_cmd(CommandC)
bob_p2p_protocol.send_pong()
bob_second_protocol.send_cmd(CommandB)
bob_third_protocol.send_cmd(CommandD)
cmd, _ = await asyncio.wait_for(alice_p2p_stream.asend(None), timeout=0.1)
assert isinstance(cmd, Pong)
cmd_1, _ = await asyncio.wait_for(bob_third_stream.asend(None), timeout=0.1) # noqa: E501
cmd_2, _ = await asyncio.wait_for(bob_third_stream.asend(None), timeout=0.1) # noqa: E501
cmd_3, _ = await asyncio.wait_for(bob_second_stream.asend(None), timeout=0.1) # noqa: E501
cmd_4, _ = await asyncio.wait_for(bob_second_stream.asend(None), timeout=0.1) # noqa: E501
cmd_5, _ = await asyncio.wait_for(alice_third_stream.asend(None), timeout=0.1) # noqa: E501
cmd_6, _ = await asyncio.wait_for(alice_third_stream.asend(None), timeout=0.1) # noqa: E501
cmd_7, _ = await asyncio.wait_for(alice_second_stream.asend(None), timeout=0.1) # noqa: E501
cmd_8, _ = await asyncio.wait_for(alice_second_stream.asend(None), timeout=0.1) # noqa: E501
assert isinstance(cmd_1, CommandC)
assert isinstance(cmd_2, CommandD)
assert isinstance(cmd_3, CommandA)
assert isinstance(cmd_4, CommandB)
assert isinstance(cmd_5, CommandC)
assert isinstance(cmd_6, CommandD)
assert isinstance(cmd_7, CommandA)
assert isinstance(cmd_8, CommandB)
async def test_multiplexer_only_p2p_protocol():
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory()
async with alice_multiplexer.multiplex():
async with bob_multiplexer.multiplex():
alice_stream = alice_multiplexer.stream_protocol_messages(P2PProtocolV5)
bob_stream = bob_multiplexer.stream_protocol_messages(P2PProtocolV5)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(P2PProtocolV5)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(P2PProtocolV5)
alice_p2p_protocol.send_ping()
cmd, _ = await asyncio.wait_for(bob_stream.asend(None), timeout=0.1)
assert isinstance(cmd, Ping)
bob_p2p_protocol.send_pong()
cmd, _ = await asyncio.wait_for(alice_stream.asend(None), timeout=0.1)