def test_creating_peer():
p2p_api = P2P_API()
peer = p2p_api.create_a_peer(role='role',
name='name',
host=('0.0.0.0', 8000))
assert p2p_api.peer.stopped.is_set() is False
p2p_api.stop_peer_thread(peer)
def test_update_chain():
# creates a P2P_API object
p2p_api = P2P_API()
# creates a peer named core
peer = p2p_api.create_a_peer(role='core',
name='core',
host=('0.0.0.0', 8000))
# creates a dummy peer for testing purposes
dummy_peer = p2p_api.create_a_peer(role="sw",
name="switch_1",
host=("127.0.0.1", 8011))
# creates an instance of Client with the specified peer above
client_1 = Client(create_blockchain(10), peer, dummy_peer)
# creates a peer named switch_2 with the role sw
peer2 = p2p_api.create_a_peer(role='sw',
name='switch_2',
host=('0.0.0.0', 8012))
# creates a Client with the specified peer above and connect it to the peer of client 1
client_2 = Client(create_blockchain(16), peer2, client_1.peer)
# creates a peer named switch_3 with the role sw
peer3 = p2p_api.create_a_peer(role='sw',
name='switch_3',
host=('0.0.0.0', 8013))
# creates a Client with the specified peer above and connect it to the peer of client 1
client_3 = Client(create_blockchain(15), peer3, client_1.peer)
def test_clients_send_block_broadcast():
""" test case for broadcasting between two clients"""
# creates a P2P_API object
p2p_api = P2P_API()
# creates a peer named core
peer = p2p_api.create_a_peer(role='core',
name='core',
host=('0.0.0.0', 8000))
dummy_peer = p2p_api.create_a_peer(role="sw",
name="switch_1",
host=("127.0.0.1", 8011))
# creates an instance of Client with the specified peer above
client_1 = Client(create_blockchain(2), peer, dummy_peer)
# creates a peer named switch_2 with the role sw
peer2 = p2p_api.create_a_peer(role='sw',
name='switch_2',
host=('0.0.0.0', 8012))
# creates a Client with the specified peer above and connect it to the peer of client 1
client_2 = Client(create_blockchain(3), peer2, client_1.peer)
peer3 = p2p_api.create_a_peer(role='sw',
name='switch_3',
host=('0.0.0.0', 8013))
# creates a Client with the specified peer above and connect it to the peer of client 1
client_3 = Client(create_blockchain(3), peer3, client_1.peer)
def json_string_block():
"""creates a main block for testing purposes"""
prev_hash = "1"
miner = "2"
difficulty = "3"
mb = MainBlock(prev_hash, miner, difficulty, [], [], [])
# time is automatically set, so we need to change it for the test
mb.time = 1562228422767
return mb.string()
json_string_message = json_string_block()
time.sleep(10)
# sends a broadcast message from client 1 to client 2
p2p_api.send_broadcast(client_1.peer, json_string_message)
time.sleep(10)
# sets block_received event
client_2.event_manager.block_received.set()
client_3.event_manager.block_received.set()
assert client_2.p2p_api.get_recv_block(
peer2.server_info.host) == json_string_message
assert client_3.p2p_api.get_recv_block(
peer3.server_info.host) == json_string_message
time.sleep(3)
remove_database()
client_1.p2p_api.event_mg.error.set()
client_2.p2p_api.event_mg.error.set()
client_3.p2p_api.event_mg.error.set()
def test_peer_integration_broadcast():
# creates an object of p2p api
peer1_api = P2P_API()
# creates a peer through API
# peer1 = peer1_api.create_a_peer(('0.0.0.0', 8001))
# creates a peer directly from Peer class
peer1 = Peer(('0.0.0.0', 8001))
peer1.start()
# creates an object of p2p api
peer2_api = P2P_API()
# creates a peer
peer2 = Peer(('0.0.0.0', 8002))
peer2.start()
# connects peer 1 to peer 2 through API
# peer1_api.connect(peer1, peer2)
# connects peer 1 to peer 2 directly
peer1.onProcess([
'join', '{}:{}'.format(peer2.server_info.host[0],
peer2.server_info.host[1])
])
time.sleep(1)
# checks if the peer 1 has created a net
assert ('0.0.0.0', 8001) == list(peer2.peer_pool.keys())[0]
# peer 2 sends a "123" broadcast to connected peers in the net
peer2_api.send_broadcast(peer2, "123")
rcv_message = str(get_messages(peer1.server_info.host))
assert "123" == rcv_message
time.sleep(5)
remove_database()
peer1.stop()
peer2.stop()
def test_clients_send_tx_broadcast():
""" test case for broadcasting between two clients"""
# creates a P2P_API object
p2p_api = P2P_API()
# creates a peer named core
peer = p2p_api.create_a_peer(role='core',
name='core',
host=('0.0.0.0', 8000))
# creates a dummy peer for testing purposes
dummy_peer = p2p_api.create_a_peer(role="sw",
name="switch_1",
host=("127.0.0.1", 8011))
# creates an instance of Client with the specified peer above
client_1 = Client(create_blockchain(2), peer, dummy_peer)
# creates a peer named switch_2 with the role sw
peer2 = p2p_api.create_a_peer(role='sw',
name='switch_2',
host=('0.0.0.0', 8012))
# creates a Client with the specified peer above and connect it to the peer of client 1
client_2 = Client(create_blockchain(2), peer2, client_1.peer)
# creates a peer named switch_3 with the role sw
peer3 = p2p_api.create_a_peer(role='sw',
name='switch_3',
host=('0.0.0.0', 8013))
# creates a Client with the specified peer above and connect it to the peer of client 1
client_3 = Client(create_blockchain(2), peer3, client_1.peer)
def json_string_tx():
"""creates a main block for testing purposes"""
sender = "iWVjc8hWuRuePAv1X8nDZdcjKcqivDUH62YKhBXBHqp2yGfgeXyHJDj5XwCHwjWB6GevCjMYT59XSBiQvMYHQ4P"
receivers = ["01", "02", "0a"]
amounts = [1, 2, 3]
fee = 100
tx = Transaction(sender, receivers, amounts, fee)
return tx.string()
json_string_message = json_string_tx()
time.sleep(15)
# sends a broadcast message from client 1 to client 2
p2p_api.send_broadcast(client_1.peer, json_string_message)
time.sleep(10)
# sets block_received event
client_2.event_manager.tx_received.set()
client_3.event_manager.tx_received.set()
assert client_2.p2p_api.get_recv_tx(
peer2.server_info.host) == json_string_message
time.sleep(3)
remove_database()
client_1.p2p_api.event_mg.error.set()
client_2.p2p_api.event_mg.error.set()
def __init__(self):
threading.Thread.__init__(self)
#self.wallet = wallet_database.load_wallet()
self.p2p_api = P2P_API()
self.vote_pool = VotePool()
self.tx_pool = TransactionPool()
self.vtx_pool = TransactionPool()
self.main_block_pool = BlockPool()
self.shard_block_pool = BlockPool()
self.event_manager = self.p2p_api.event_mg
self.stop = threading.Event()
self.state = State.DEFAULT
def test_join_peers():
p2p_api = P2P_API()
p2p_api.peer_1 = create_a_peer(role='role',
name='peer1',
host=('0.0.0.0', 8000))
p2p_api.peer_2 = create_a_peer(role='role',
name='peer2',
host=('0.0.0.0', 8001))
p2p_api.join_peers(peer_1, peer_2)
time.sleep(4)
assert p2p_api.peer_2.server_info in p2p_api.peer_1.connectlist
time.sleep(4)
p2p_api.p2p_apistop_peer_thread(p2p_api.peer_1)
p2p_api.stop_peer_thread(p2p_api.peer_2)
def test_list_peers_in_net():
p2p_api = P2P_API()
p2p_api.peer_1 = p2p_api.create_a_peer(role='role',
name='peer1',
host=('0.0.0.0', 8000))
p2p_api.peer_2 = p2p_api.create_a_peer(role='role',
name='peer2',
host=('0.0.0.0', 8001))
p2p_api.join_peers(p2p_api.peer_1, p2p_api.peer_2)
time.sleep(4)
list_of_peers = len(p2p_api.list_peers_in_net(p2p_api.peer_1))
assert list_of_peers == 1
time.sleep(4)
p2p_api.stop_peer_thread(p2p_api.peer_1)
p2p_api.stop_peer_thread(p2p_api.peer_2)
def test_mesh_peer_integration():
#ToDo: FIX - can't reach p1 and p6
peer_api = P2P_API()
p1 = Peer(('0.0.0.0', 50501))
p1.start()
p2 = Peer(('0.0.0.0', 50502))
p2.start()
p3 = Peer(('0.0.0.0', 50503))
p3.start()
p4 = Peer(('0.0.0.0', 50504))
p4.start()
p5 = Peer(('0.0.0.0', 50505))
p5.start()
p6 = Peer(('0.0.0.0', 50506))
p6.start()
time.sleep(5)
p1.onProcess([
'join', '{}:{}'.format(p2.server_info.host[0], p2.server_info.host[1])
])
time.sleep(2)
p2.onProcess([
'join', '{}:{}'.format(p3.server_info.host[0], p3.server_info.host[1])
])
time.sleep(2)
p3.onProcess([
'join', '{}:{}'.format(p4.server_info.host[0], p4.server_info.host[1])
])
time.sleep(2)
p3.onProcess([
'join', '{}:{}'.format(p5.server_info.host[0], p5.server_info.host[1])
])
time.sleep(2)
p5.onProcess([
'join', '{}:{}'.format(p6.server_info.host[0], p6.server_info.host[1])
])
peer_api.send_broadcast(p3, "123")
time.sleep(3)
def test_send_broadcast():
p2p_api = P2P_API()
# creates a dictionary for nodes
node = dict()
# creates a core peer
node['core_1'] = p2p_api.create_a_peer(role='core',
name='core_1',
host=('127.0.0.1', 8000))
# create switch peers
node['switch_1'] = p2p_api.create_a_peer(role='sw',
name='switch_1',
host=('127.0.0.1', 8011))
node['switch_2'] = p2p_api.create_a_peer(role='sw',
name='switch_2',
host=('127.0.0.1', 8012))
node['switch_3'] = p2p_api.create_a_peer(role='sw',
name='switch_3',
host=('127.0.0.1', 8013))
node['switch_4'] = p2p_api.create_a_peer(role='sw',
name='switch_4',
host=('127.0.0.1', 8014))
#node['switch_5'] = create_a_peer(role='sw', name='switch_5', host=('127.0.0.1', 8015))
#node['switch_6'] = create_a_peer(role='sw', name='switch_6', host=('127.0.0.1', 8016))
p2p_api.join_peers(node['switch_1'], node['core_1'])
p2p_api.join_peers(node['switch_2'], node['core_1'])
p2p_api.join_peers(node['switch_3'], node['core_1'])
p2p_api.join_peers(node['switch_4'], node['core_1'])
#join_peers(node['switch_5'], node['switch_4'])
#join_peers(node['switch_6'], node['switch_4'])
# wait for all threads to complete the join process
time.sleep(5)
print("test")
print(node)
p2p_api.send_broadcast(node['core_1'], 'StringToBeSent')
time.sleep(5)
for (key, val) in node.items():
p2p_api.stop_peer_thread(val)
time.sleep(2)
def test_multiple_peer_chain_integration():
peer_api = P2P_API()
p1 = Peer(('0.0.0.0', 50501))
p1.start()
p2 = Peer(('0.0.0.0', 50502))
p2.start()
p3 = Peer(('0.0.0.0', 50503))
p3.start()
p4 = Peer(('0.0.0.0', 50504))
p4.start()
p5 = Peer(('0.0.0.0', 50505))
p5.start()
p6 = Peer(('0.0.0.0', 50506))
p6.start()
time.sleep(5)
p1.onProcess([
'join', '{}:{}'.format(p2.server_info.host[0], p2.server_info.host[1])
])
time.sleep(2)
p2.onProcess([
'join', '{}:{}'.format(p3.server_info.host[0], p3.server_info.host[1])
])
time.sleep(2)
p3.onProcess([
'join', '{}:{}'.format(p4.server_info.host[0], p4.server_info.host[1])
])
time.sleep(2)
p4.onProcess([
'join', '{}:{}'.format(p5.server_info.host[0], p5.server_info.host[1])
])
time.sleep(2)
p5.onProcess([
'join', '{}:{}'.format(p6.server_info.host[0], p6.server_info.host[1])
])
time.sleep(2)
p6.onProcess([
'join', '{}:{}'.format(p5.server_info.host[0], p5.server_info.host[1])
])
time.sleep(2)
peer_api.send_broadcast(p2, "123")
time.sleep(300 / 1000)
peer_api.send_broadcast(p3, "123")
time.sleep(300 / 1000)
peer_api.send_broadcast(p4, "123")
time.sleep(300 / 1000)
peer_api.send_broadcast(p5, "123")
time.sleep(300 / 1000)
peer_api.send_broadcast(p6, "123")
time.sleep(3)
# checks whether the specific peer is connected with peer/peers
assert ('0.0.0.0', 50502) == list(p1.peer_pool.keys())[0]
assert ('0.0.0.0', 50501) == list(
p2.peer_pool.keys())[0] and ('0.0.0.0', 50503) == list(
p2.peer_pool.keys())[1]
assert ('0.0.0.0', 50502) == list(
p3.peer_pool.keys())[0] and ('0.0.0.0', 50504) == list(
p3.peer_pool.keys())[1]
assert ('0.0.0.0', 50503) == list(
p4.peer_pool.keys())[0] and ('0.0.0.0', 50505) == list(
p4.peer_pool.keys())[1]
assert ('0.0.0.0', 50504) == list(
p5.peer_pool.keys())[0] and ('0.0.0.0', 50506) == list(
p5.peer_pool.keys())[1]
assert ('0.0.0.0', 50505) == list(p6.peer_pool.keys())[0]
rcv_message_1 = str(get_messages(p1.server_info.host))
rcv_message_2 = str(get_messages(p2.server_info.host))
rcv_message_3 = str(get_messages(p3.server_info.host))
rcv_message_4 = str(get_messages(p4.server_info.host))
rcv_message_5 = str(get_messages(p5.server_info.host))
rcv_message_6 = str(get_messages(p6.server_info.host))
assert "123" == rcv_message_1 and "123" == rcv_message_2 and "123" == rcv_message_3
assert "123" == rcv_message_4 and "123" == rcv_message_5
# assert "123" == rcv_message_6
remove_database()
time.sleep(2)
p1.stop() and p2.stop() and p3.stop() and p4.stop() and p5.stop(
) and p6.stop()