2018-09-30 14:12:02 +00:00
|
|
|
import os
|
2018-10-06 15:01:03 +00:00
|
|
|
import asyncio
|
2018-10-09 01:29:51 +00:00
|
|
|
import pytest
|
2018-10-07 16:23:27 +00:00
|
|
|
from p2pfs import Peer, Tracker
|
2018-10-09 05:27:01 +00:00
|
|
|
import time
|
2018-10-09 01:29:51 +00:00
|
|
|
from tests.conftest import fmd5, TEST_SMALL_FILE, TEST_LARGE_FILE, TEST_SMALL_FILE_SIZE, TEST_LARGE_FILE_SIZE
|
2018-10-06 15:01:03 +00:00
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
pytestmark = pytest.mark.asyncio
|
2018-09-30 14:12:02 +00:00
|
|
|
|
2018-10-08 17:51:02 +00:00
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
async def test_server_refused(unused_tcp_port):
|
|
|
|
peer = Peer('localhost', 0, 'localhost', unused_tcp_port)
|
|
|
|
started = await peer.start()
|
2018-10-02 01:47:53 +00:00
|
|
|
assert not started
|
|
|
|
|
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
async def test_start_stop(unused_tcp_port):
|
|
|
|
tracker = Tracker('localhost', unused_tcp_port)
|
|
|
|
peers = tuple(Peer('localhost', 0, 'localhost', unused_tcp_port) for _ in range(3))
|
|
|
|
tracker_started = await tracker.start()
|
2018-10-08 03:27:22 +00:00
|
|
|
# spawn peers concurrently
|
2018-10-09 01:29:51 +00:00
|
|
|
peers_started = await asyncio.gather(*[peer.start() for peer in peers])
|
2018-10-08 03:19:37 +00:00
|
|
|
assert tracker_started and all(peers_started)
|
2018-10-01 19:17:53 +00:00
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
await tracker.stop()
|
|
|
|
await asyncio.gather(*[peer.stop() for peer in peers])
|
2018-10-08 18:00:45 +00:00
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
|
|
|
|
async def test_publish_refuse(unused_tcp_port):
|
|
|
|
tracker = Tracker('localhost', unused_tcp_port)
|
|
|
|
peers = tuple(Peer('localhost', 0, 'localhost', unused_tcp_port) for _ in range(3))
|
|
|
|
tracker_started = await tracker.start()
|
|
|
|
# spawn peers concurrently
|
|
|
|
peers_started = await asyncio.gather(*[peer.start() for peer in peers])
|
|
|
|
assert tracker_started and all(peers_started)
|
2018-10-08 18:10:39 +00:00
|
|
|
with open('test_publish_refuse', 'wb') as fout:
|
|
|
|
fout.write(os.urandom(100))
|
2018-10-09 01:29:51 +00:00
|
|
|
is_success, _ = await peers[0].publish('test_publish_refuse')
|
2018-10-08 18:10:39 +00:00
|
|
|
assert is_success
|
2018-10-09 01:29:51 +00:00
|
|
|
is_success, _ = await peers[0].publish('test_publish_refuse')
|
2018-10-08 18:10:39 +00:00
|
|
|
assert not is_success
|
2018-10-09 01:29:51 +00:00
|
|
|
os.remove('test_publish_refuse')
|
|
|
|
await tracker.stop()
|
|
|
|
await asyncio.gather(*[peer.stop() for peer in peers])
|
2018-10-08 18:10:39 +00:00
|
|
|
|
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
async def test_publish(unused_tcp_port):
|
|
|
|
tracker = Tracker('localhost', unused_tcp_port)
|
|
|
|
peers = tuple(Peer('localhost', 0, 'localhost', unused_tcp_port) for _ in range(2))
|
|
|
|
tracker_started = await tracker.start()
|
|
|
|
peer_started = await asyncio.gather(*[peer.start() for peer in peers])
|
|
|
|
assert tracker_started and peer_started
|
|
|
|
|
|
|
|
# peer0 publishes a small_file and peer1 publishes a large file
|
|
|
|
is_success, _ = await peers[0].publish(TEST_SMALL_FILE)
|
2018-10-08 18:09:11 +00:00
|
|
|
assert is_success
|
2018-09-30 14:12:02 +00:00
|
|
|
file_list = tracker.file_list()
|
2018-10-08 17:51:02 +00:00
|
|
|
assert TEST_SMALL_FILE in file_list
|
2018-10-08 18:08:30 +00:00
|
|
|
assert file_list[TEST_SMALL_FILE]['size'] == TEST_SMALL_FILE_SIZE
|
2018-10-09 01:29:51 +00:00
|
|
|
file_list = await peers[1].list_file()
|
2018-10-08 17:51:02 +00:00
|
|
|
assert TEST_SMALL_FILE in file_list
|
2018-10-04 04:01:22 +00:00
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
is_success, _ = await peers[1].publish(TEST_LARGE_FILE)
|
|
|
|
assert is_success
|
|
|
|
file_list = tracker.file_list()
|
|
|
|
assert TEST_LARGE_FILE in file_list and TEST_SMALL_FILE in file_list
|
|
|
|
assert file_list[TEST_LARGE_FILE]['size'] == TEST_LARGE_FILE_SIZE
|
|
|
|
file_list = await peers[0].list_file()
|
|
|
|
assert TEST_LARGE_FILE in file_list and TEST_SMALL_FILE in file_list
|
|
|
|
await tracker.stop()
|
|
|
|
await asyncio.gather(*[peer.stop() for peer in peers])
|
|
|
|
|
|
|
|
|
|
|
|
async def test_download(unused_tcp_port):
|
|
|
|
tracker = Tracker('localhost', unused_tcp_port)
|
|
|
|
peers = tuple(Peer('localhost', 0, 'localhost', unused_tcp_port) for _ in range(3))
|
|
|
|
tracker_started = await tracker.start()
|
|
|
|
peer_started = await asyncio.gather(*[peer.start() for peer in peers])
|
|
|
|
assert tracker_started and peer_started
|
|
|
|
|
|
|
|
# peer0 publishes a small_file and peer1 publishes a large file
|
|
|
|
is_success, _ = await peers[0].publish(TEST_SMALL_FILE)
|
|
|
|
assert is_success
|
|
|
|
file_list = tracker.file_list()
|
|
|
|
assert TEST_SMALL_FILE in file_list
|
|
|
|
assert file_list[TEST_SMALL_FILE]['size'] == TEST_SMALL_FILE_SIZE
|
|
|
|
file_list = await peers[1].list_file()
|
|
|
|
assert TEST_SMALL_FILE in file_list
|
|
|
|
|
|
|
|
is_success, _ = await peers[1].publish(TEST_LARGE_FILE)
|
|
|
|
assert is_success
|
|
|
|
file_list = tracker.file_list()
|
|
|
|
assert TEST_LARGE_FILE in file_list and TEST_SMALL_FILE in file_list
|
|
|
|
assert file_list[TEST_LARGE_FILE]['size'] == TEST_LARGE_FILE_SIZE
|
|
|
|
file_list = await peers[0].list_file()
|
|
|
|
assert TEST_LARGE_FILE in file_list and TEST_SMALL_FILE in file_list
|
2018-10-08 18:00:45 +00:00
|
|
|
|
2018-10-04 04:01:22 +00:00
|
|
|
def reporthook(chunk_num, chunk_size, total_size):
|
|
|
|
reporthook.value = (chunk_num, total_size)
|
|
|
|
|
2018-10-08 03:27:22 +00:00
|
|
|
# download small file
|
2018-10-09 01:29:51 +00:00
|
|
|
result, msg = await peers[1].download(TEST_SMALL_FILE, 'downloaded_' + TEST_SMALL_FILE, reporthook=reporthook)
|
2018-09-30 14:12:02 +00:00
|
|
|
assert result is True
|
2018-10-08 18:00:45 +00:00
|
|
|
assert os.path.exists('downloaded_' + TEST_SMALL_FILE)
|
|
|
|
assert fmd5(TEST_SMALL_FILE) == fmd5('downloaded_' + TEST_SMALL_FILE)
|
2018-10-04 04:01:22 +00:00
|
|
|
assert reporthook.value == (1, 1000)
|
2018-10-08 18:00:45 +00:00
|
|
|
os.remove('downloaded_' + TEST_SMALL_FILE)
|
2018-09-30 14:12:02 +00:00
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
# download large file from single source
|
|
|
|
result, msg = await peers[0].download(TEST_LARGE_FILE, 'downloaded_' + TEST_LARGE_FILE + '_0')
|
2018-09-30 14:12:02 +00:00
|
|
|
assert result is True
|
2018-10-09 01:29:51 +00:00
|
|
|
assert os.path.exists('downloaded_' + TEST_LARGE_FILE + '_0')
|
|
|
|
assert fmd5(TEST_LARGE_FILE) == fmd5('downloaded_' + TEST_LARGE_FILE + '_0')
|
2018-10-08 18:00:45 +00:00
|
|
|
|
2018-10-09 01:29:51 +00:00
|
|
|
# download large file from multiple sources
|
|
|
|
result, msg = await peers[2].download(TEST_LARGE_FILE, 'downloaded_' + TEST_LARGE_FILE + '_2')
|
2018-10-08 03:27:22 +00:00
|
|
|
assert result is True
|
2018-10-09 01:29:51 +00:00
|
|
|
assert os.path.exists('downloaded_' + TEST_LARGE_FILE + '_2')
|
|
|
|
assert fmd5(TEST_LARGE_FILE) == fmd5('downloaded_' + TEST_LARGE_FILE + '_2')
|
|
|
|
os.remove('downloaded_' + TEST_LARGE_FILE + '_0')
|
|
|
|
os.remove('downloaded_' + TEST_LARGE_FILE + '_2')
|
|
|
|
|
|
|
|
await tracker.stop()
|
|
|
|
await asyncio.gather(*[peer.stop() for peer in peers])
|
2018-10-09 04:26:42 +00:00
|
|
|
|
|
|
|
|
2018-10-09 05:27:01 +00:00
|
|
|
async def test_delay(unused_tcp_port):
|
|
|
|
tracker = Tracker('localhost', unused_tcp_port)
|
|
|
|
peers = tuple(Peer('localhost', 0, 'localhost', unused_tcp_port) for _ in range(2))
|
|
|
|
tracker_started = await tracker.start()
|
|
|
|
peer_started = await asyncio.gather(*[peer.start() for peer in peers])
|
|
|
|
assert tracker_started and peer_started
|
|
|
|
|
|
|
|
# peer0 publishes a small_file and peer1 publishes a large file
|
|
|
|
is_success, _ = await peers[0].publish(TEST_SMALL_FILE)
|
|
|
|
assert is_success
|
|
|
|
file_list = tracker.file_list()
|
|
|
|
assert TEST_SMALL_FILE in file_list
|
|
|
|
assert file_list[TEST_SMALL_FILE]['size'] == TEST_SMALL_FILE_SIZE
|
|
|
|
file_list = await peers[1].list_file()
|
|
|
|
assert TEST_SMALL_FILE in file_list
|
|
|
|
|
|
|
|
# download small file
|
|
|
|
start = time.time()
|
|
|
|
result, msg = await peers[1].download(TEST_SMALL_FILE, 'downloaded_' + TEST_SMALL_FILE)
|
|
|
|
assert result is True
|
|
|
|
assert os.path.exists('downloaded_' + TEST_SMALL_FILE)
|
|
|
|
assert fmd5(TEST_SMALL_FILE) == fmd5('downloaded_' + TEST_SMALL_FILE)
|
|
|
|
os.remove('downloaded_' + TEST_SMALL_FILE)
|
|
|
|
download_time = time.time() - start
|
|
|
|
start = time.time()
|
|
|
|
peers[0].set_delay(1)
|
|
|
|
result, msg = await peers[1].download(TEST_SMALL_FILE, 'downloaded_' + TEST_SMALL_FILE)
|
|
|
|
assert result is True
|
|
|
|
download_time_with_delay = time.time() - start
|
|
|
|
assert download_time_with_delay > download_time
|
|
|
|
peers[0].set_delay(0)
|
|
|
|
|
|
|
|
await tracker.stop()
|
|
|
|
await asyncio.gather(*[peer.stop() for peer in peers])
|
|
|
|
|
|
|
|
|
2018-10-09 04:26:42 +00:00
|
|
|
async def test_peer_disconnect(unused_tcp_port):
|
|
|
|
tracker = Tracker('localhost', unused_tcp_port)
|
|
|
|
peer = Peer('localhost', 0, 'localhost', unused_tcp_port)
|
|
|
|
tracker_started = await tracker.start()
|
|
|
|
peer_started = await peer.start()
|
|
|
|
assert tracker_started and peer_started
|
|
|
|
|
|
|
|
is_suceess, _ = await peer.publish(TEST_SMALL_FILE)
|
|
|
|
assert is_suceess
|
|
|
|
assert TEST_SMALL_FILE in tracker.file_list()
|
|
|
|
|
|
|
|
# stop peer and check the file has been removed
|
|
|
|
await peer.stop()
|
|
|
|
# return control to the loop for tracker code to run
|
2018-10-09 05:27:48 +00:00
|
|
|
await asyncio.sleep(1)
|
2018-10-09 04:26:42 +00:00
|
|
|
assert TEST_SMALL_FILE not in tracker.file_list()
|
|
|
|
|
|
|
|
await tracker.stop()
|