def test_node_constructor(): privkey = PrivateKeyFactory() address = AddressFactory() enr = ENRFactory(private_key=privkey.to_bytes(), address=address) node = Node(enr) assert node.id == keccak(privkey.public_key.to_bytes()) assert node.address == address
def test_node_from_enr_uri(): privkey = PrivateKeyFactory() address = AddressFactory() enr = ENRFactory(private_key=privkey.to_bytes(), address=address) node = Node.from_uri(repr(enr)) assert node.id == keccak(privkey.public_key.to_bytes()) assert node.address == address
async def test_lookup_and_maybe_update_enr_existing_node(): discovery = MockDiscoveryService([]) privkey = PrivateKeyFactory() address = AddressFactory() # When we have an ENR for the given pubkey, and its address matches the given one, the # existing ENR is returned. enr = ENRFactory(private_key=privkey.to_bytes(), address=address) discovery.enr_db.set_enr(enr) lookedup_enr = discovery.lookup_and_maybe_update_enr(privkey.public_key, address) assert lookedup_enr == enr
async def test_lookup_and_maybe_update_enr_existing_node_different_address(): discovery = MockDiscoveryService([]) privkey = PrivateKeyFactory() address = AddressFactory() # If the address given is different than the one we have in our DB, though, a stub ENR would # be created and stored in our DB, replacing the existing one. enr = ENRFactory(private_key=privkey.to_bytes(), address=address) discovery.enr_db.set_enr(enr) new_address = AddressFactory() lookedup_enr = discovery.lookup_and_maybe_update_enr(privkey.public_key, new_address) assert lookedup_enr != enr assert lookedup_enr.public_key == enr.public_key assert lookedup_enr.sequence_number == 0 assert Node(lookedup_enr).address == new_address assert lookedup_enr == discovery.enr_db.get_enr(enr.node_id)
async def test_connection_properties(): Protocol_A = ProtocolFactory() Protocol_B = ProtocolFactory() alice_handshakers = (NoopHandshaker(Protocol_A), ) bob_handshakers = (NoopHandshaker(Protocol_A), NoopHandshaker(Protocol_B)) bob_capabilities = (Protocol_A.as_capability(), Protocol_B.as_capability()) bob_remote = NodeFactory() bob_private_key = PrivateKeyFactory() pair_factory = ConnectionPairFactory( alice_handshakers=alice_handshakers, bob_handshakers=bob_handshakers, alice_p2p_version=DEVP2P_V4, bob_client_version='bob-client', bob_p2p_version=DEVP2P_V5, bob_private_key=bob_private_key, bob_remote=bob_remote, ) async with pair_factory as (connection, _): assert type(connection.get_base_protocol()) is P2PProtocolV4 assert connection.remote_capabilities == bob_capabilities assert connection.remote_p2p_version == DEVP2P_V5 assert connection.negotiated_p2p_version == DEVP2P_V4 assert connection.remote_public_key == bob_private_key.public_key assert connection.client_version_string == 'bob-client' assert connection.safe_client_version_string == 'bob-client'
def test_node_constructor(): privkey = PrivateKeyFactory() ip = socket.inet_aton(IPAddressFactory.generate()) udp_port = tcp_port = 30303 enr = ENRFactory(private_key=privkey.to_bytes(), custom_kv_pairs={ IP_V4_ADDRESS_ENR_KEY: ip, UDP_PORT_ENR_KEY: udp_port }) node = Node(enr) assert node.id == keccak(privkey.public_key.to_bytes()) assert node.address.ip_packed == ip assert node.address.tcp_port == tcp_port assert node.address.udp_port == udp_port
def test_discover_v4_message_pack(): sender, recipient = AddressFactory.create_batch(2) version = rlp.sedes.big_endian_int.serialize(PROTO_VERSION) payload = (version, sender.to_endpoint(), recipient.to_endpoint()) privkey = PrivateKeyFactory() message = _pack_v4(CMD_PING.id, payload, privkey) pubkey, cmd_id, payload, _ = _unpack_v4(message) assert pubkey == privkey.public_key assert cmd_id == CMD_PING.id
async def test_lookup_and_maybe_update_enr_new_node(): discovery = MockDiscoveryService([]) privkey = PrivateKeyFactory() address = AddressFactory() # When looking up the ENR for a node we haven't heard about before, we'll create a stub ENR # and add that into our DB. enr = discovery.lookup_and_maybe_update_enr(privkey.public_key, address) assert enr.sequence_number == 0 node = Node(enr) assert node.pubkey == privkey.public_key assert node.address == address db_enr = discovery.enr_db.get_enr(node.id) assert db_enr == enr
async def test_bootstrap_nodes(): private_key = PrivateKeyFactory().to_bytes() bootnode1 = ENRFactory(private_key=private_key) bootnode2 = ENRFactory() discovery = MockDiscoveryService([Node(bootnode1), Node(bootnode2)]) assert discovery.enr_db.get_enr(bootnode1.node_id) == bootnode1 assert discovery.enr_db.get_enr(bootnode2.node_id) == bootnode2 assert [node.enr for node in discovery.bootstrap_nodes] == [bootnode1, bootnode2] # If our DB gets updated with a newer ENR of one of our bootnodes, the @bootstrap_nodes # property will reflect that. new_bootnode1 = ENRFactory( private_key=private_key, sequence_number=bootnode1.sequence_number + 1) discovery.enr_db.set_enr(new_bootnode1) assert [node.enr for node in discovery.bootstrap_nodes] == [new_bootnode1, bootnode2]
def _create(cls, model_class: Type[BaseTransactionFields], *args: Any, **kwargs: Any) -> BaseTransactionFields: if 'vrs' in kwargs: v, r, s = kwargs.pop('vrs') else: if 'private_key' in kwargs: private_key = kwargs.pop('private_key') else: private_key = PrivateKeyFactory() tx_for_signing = FrontierUnsignedTransaction(**kwargs) signed_tx = tx_for_signing.as_signed_transaction(private_key) v = signed_tx.v r = signed_tx.r s = signed_tx.s return model_class(**kwargs, v=v, r=r, s=s)
async def get_peer_and_receive_server( request, event_loop, event_bus ) -> Tuple[BCCPeer, BCCRequestServer, BCCReceiveServer, asyncio.Queue]: alice_chain = await get_fake_chain() bob_chain = await get_fake_chain() alice_private_key = PrivateKeyFactory() bob_private_key = PrivateKeyFactory() alice_context = BeaconContextFactory(chain_db=alice_chain.chaindb) bob_context = BeaconContextFactory(chain_db=bob_chain.chaindb) peer_pair = BCCPeerPairFactory( alice_peer_context=alice_context, alice_private_key=alice_private_key, bob_peer_context=bob_context, bob_private_key=bob_private_key, event_bus=event_bus, ) async with peer_pair as (alice, bob): alice_pool_ctx = BCCPeerPoolFactory.run_for_peer( alice, privkey=alice_private_key, context=alice_context, event_bus=event_bus, ) bob_pool_ctx = BCCPeerPoolFactory.run_for_peer( bob, privkey=bob_private_key, context=bob_context, event_bus=event_bus, ) async with alice_pool_ctx as alice_peer_pool, bob_pool_ctx as bob_peer_pool: msg_queue = asyncio.Queue() orig_handle_msg = BCCReceiveServer._handle_msg # Inject a queue to each `BCCReceiveServer`, which puts the message # passed to `_handle_msg` to the queue, right after every `_handle_msg` # finishes. This is crucial to make the test be able to wait until # `_handle_msg` finishes. async def _handle_msg(self, base_peer, cmd, msg): task = asyncio.ensure_future( orig_handle_msg(self, base_peer, cmd, msg)) def enqueue_msg(future, msg): msg_queue.put_nowait(msg) task.add_done_callback(functools.partial(enqueue_msg, msg=msg)) await task BCCReceiveServer._handle_msg = _handle_msg async with run_peer_pool_event_server( event_bus, alice_peer_pool, BCCPeerPoolEventServer), run_request_server( event_bus, alice_chain.chaindb, server_type=BCCRequestServer) as alice_req_server: bob_recv_server = BCCReceiveServer(chain=bob_chain, peer_pool=bob_peer_pool) asyncio.ensure_future(bob_recv_server.run()) await bob_recv_server.events.started.wait() def finalizer(): event_loop.run_until_complete(bob_recv_server.cancel()) request.addfinalizer(finalizer) yield alice, alice_req_server, bob_recv_server, msg_queue