def setUp(self):
yield super(TestTorrentHealthEndpoint, self).setUp()
min_base_port, max_base_port = self.get_bucket_range_port()
self.udp_port = get_random_port(min_port=min_base_port, max_port=max_base_port)
self.udp_tracker = UDPTracker(self.udp_port)
self.http_port = get_random_port(min_port=min_base_port, max_port=max_base_port)
self.http_tracker = HTTPTracker(self.http_port)
def setUp(self):
yield super(TestTorrentHealthEndpoint, self).setUp()
min_base_port, max_base_port = self.get_bucket_range_port()
self.udp_port = get_random_port(min_port=min_base_port,
max_port=max_base_port)
self.udp_tracker = UDPTracker(self.udp_port)
self.http_port = get_random_port(min_port=min_base_port,
max_port=max_base_port)
self.http_tracker = HTTPTracker(self.http_port)
def test_channel_update_and_download(self):
"""
Test whether we can successfully update a channel and download the new version
"""
# First we have to manually add the old version
old_payload = ChannelMetadataPayload.from_file(CHANNEL_METADATA)
with db_session:
old_channel = self.session.lm.mds.ChannelMetadata.from_payload(
old_payload)
chan_dir = os.path.join(CHANNEL_DIR, old_channel.dir_name)
self.session.lm.mds.process_channel_dir(chan_dir,
old_payload.public_key)
channel_tdef = TorrentDef.load(CHANNEL_TORRENT_UPDATED)
libtorrent_port = get_random_port()
yield self.setup_seeder(channel_tdef, CHANNEL_DIR, libtorrent_port)
payload = ChannelMetadataPayload.from_file(CHANNEL_METADATA_UPDATED)
# Download the channel in our session
download, finished_deferred = self.session.lm.update_channel(payload)
download.add_peer(
("127.0.0.1", self.seeder_session.config.get_libtorrent_port()))
yield finished_deferred
with db_session:
# There should be 4 torrents + 1 channel torrent
channel = self.session.lm.mds.ChannelMetadata.get_channel_with_id(
payload.public_key)
self.assertEqual(
5, len(list(self.session.lm.mds.TorrentMetadata.select())))
self.assertEqual(4, channel.local_version)
def test_start_download_from_bad_url(self):
"""
Testing whether starting a download from a unexisting URL gives an error
"""
post_data = {'uri': 'http://localhost:%d/test.torrent' % get_random_port()}
self.should_check_equality = False
return self.do_request('downloads', expected_code=500, request_type='PUT', post_data=post_data)
def test_start_download_from_bad_url(self):
"""
Testing whether starting a download from a unexisting URL gives an error
"""
post_data = {'uri': 'http://localhost:%d/test.torrent' % get_random_port()}
self.should_check_equality = False
return self.do_request('downloads', expected_code=500, request_type='PUT', post_data=post_data)
def test_load_from_url(self):
# Setup file server to serve torrent file
self.session_base_dir = mkdtemp(suffix="_tribler_test_load_from_url")
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE,
os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
def _on_load(torrent_def):
torrent_def.metainfo = create_valid_metainfo(
torrent_def.get_metainfo())
self.assertTrue(valid_torrent_file(torrent_def.get_metainfo()))
self.assertEqual(
torrent_def.get_metainfo(),
TorrentDef.load(TORRENT_UBUNTU_FILE).get_metainfo())
self.assertEqual(torrent_def.infohash,
TorrentDef.load(TORRENT_UBUNTU_FILE).infohash)
torrent_url = 'http://localhost:%d/ubuntu.torrent' % file_server_port
deferred = TorrentDef.load_from_url(torrent_url)
deferred.addCallback(_on_load)
return deferred
def get_socks5_ports(self):
"""
Return five random, free socks5 ports.
This is here to make sure that tests in different buckets get assigned different SOCKS5 listen ports.
Also, make sure that we have no duplicates in selected socks5 ports.
"""
socks5_ports = []
for _ in xrange(0, 5):
min_base_port, max_base_port = self.get_bucket_range_port()
selected_port = get_random_port(min_port=min_base_port, max_port=max_base_port)
while selected_port in self.selected_socks5_ports:
selected_port = get_random_port(min_port=min_base_port, max_port=max_base_port)
self.selected_socks5_ports.add(selected_port)
socks5_ports.append(selected_port)
return socks5_ports
def test_add_torrent_from_url_to_channel_with_description(self):
"""
Testing whether a torrent can be added to a channel using the API
"""
my_channel_id = self.create_fake_channel("channel", "")
# Setup file server to serve torrent file
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE,
os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
def verify_method_invocation(channel_id,
torrent_def,
extra_info=None,
forward=True):
self.assertEqual(my_channel_id, channel_id)
self.assertEqual(TorrentDef.load(TORRENT_UBUNTU_FILE), torrent_def)
self.assertEqual({"description": "test"}, extra_info or {})
self.assertEqual(True, forward)
self.session.add_torrent_def_to_channel = verify_method_invocation
torrent_url = 'http://localhost:%d/ubuntu.torrent' % file_server_port
url = 'channels/discovered/%s/torrents/%s' % (
'fakedispersyid'.encode('hex'), urllib.quote_plus(torrent_url))
return self.do_request(url,
expected_code=200,
expected_json={"added": torrent_url},
request_type='PUT',
post_data={"description": "test"})
def _get_random_port(self, path):
"""Get a random port which is not already selected."""
if path not in self.selected_ports:
self.selected_ports[path] = get_random_port()
self._logger.debug(u"Get random port %d for [%s]",
self.selected_ports[path], path)
return self.selected_ports[path]
def test_channel_update_and_download(self):
"""
Test whether we can successfully update a channel and download the new version
"""
# First we have to manually add the old version
old_payload = ChannelMetadataPayload.from_file(CHANNEL_METADATA)
with db_session:
old_channel = self.session.lm.mds.ChannelMetadata.from_payload(old_payload)
chan_dir = os.path.join(CHANNEL_DIR, old_channel.dir_name)
self.session.lm.mds.process_channel_dir(chan_dir, old_payload.public_key)
channel_tdef = TorrentDef.load(CHANNEL_TORRENT_UPDATED)
libtorrent_port = get_random_port()
yield self.setup_seeder(channel_tdef, CHANNEL_DIR, libtorrent_port)
payload = ChannelMetadataPayload.from_file(CHANNEL_METADATA_UPDATED)
# Download the channel in our session
download, finished_deferred = self.session.lm.update_channel(payload)
download.add_peer(("127.0.0.1", self.seeder_session.config.get_libtorrent_port()))
yield finished_deferred
with db_session:
# There should be 4 torrents + 1 channel torrent
channel = self.session.lm.mds.ChannelMetadata.get_channel_with_id(payload.public_key)
self.assertEqual(5, len(list(self.session.lm.mds.TorrentMetadata.select())))
self.assertEqual(4, channel.local_version)
def get_socks5_ports(self):
"""
Return five random, free socks5 ports.
This is here to make sure that tests in different buckets get assigned different SOCKS5 listen ports.
Also, make sure that we have no duplicates in selected socks5 ports.
"""
socks5_ports = []
for _ in xrange(0, 5):
min_base_port, max_base_port = self.get_bucket_range_port()
selected_port = get_random_port(min_port=min_base_port, max_port=max_base_port)
while selected_port in self.selected_socks5_ports:
selected_port = get_random_port(min_port=min_base_port, max_port=max_base_port)
self.selected_socks5_ports.add(selected_port)
socks5_ports.append(selected_port)
return socks5_ports
def test_get_random_port_tcp(self):
rand_port_num = random.randint(*self.get_bucket_range_port())
listenport = reactor.listenTCP(rand_port_num, Factory())
random_port = get_random_port(socket_type='tcp',
min_port=rand_port_num,
max_port=rand_port_num)
self.assertGreaterEqual(random_port, rand_port_num + 1)
return listenport.stopListening()
def test_get_torrentinfo(self):
"""
Testing whether the API returns a correct dictionary with torrent info.
"""
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_FILE, os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
def verify_valid_dict(data):
metainfo_dict = json.loads(data)
self.assertTrue('metainfo' in metainfo_dict)
self.assertTrue('info' in metainfo_dict['metainfo'])
self.should_check_equality = False
yield self.do_request('torrentinfo', expected_code=400)
yield self.do_request('torrentinfo?uri=def', expected_code=400)
path = "file:" + pathname2url(os.path.join(TESTS_DATA_DIR, "bak_single.torrent")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
path = "http://localhost:%d/ubuntu.torrent" % file_server_port
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
def get_metainfo(infohash, callback, **_):
with open(os.path.join(TESTS_DATA_DIR, "bak_single.torrent"), mode='rb') as torrent_file:
torrent_data = torrent_file.read()
tdef = TorrentDef.load_from_memory(torrent_data)
callback(tdef.get_metainfo())
def get_metainfo_timeout(*args, **kwargs):
timeout_cb = kwargs.get('timeout_callback')
timeout_cb('a' * 20)
path = 'magnet:?xt=urn:btih:%s&dn=%s' % (hexlify(UBUNTU_1504_INFOHASH), quote_plus('test torrent'))
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = get_metainfo
self.session.lm.ltmgr.shutdown = lambda: None
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict) # Cached
path = 'magnet:?xt=urn:btih:%s&dn=%s' % ('a' * 40, quote_plus('test torrent'))
self.session.lm.ltmgr.get_metainfo = get_metainfo_timeout
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=408)
def mocked_save_torrent(*_):
raise TypeError()
self.session.lm.ltmgr.get_metainfo = get_metainfo
self.session.save_collected_torrent = mocked_save_torrent
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
path = 'http://fdsafksdlafdslkdksdlfjs9fsafasdf7lkdzz32.n38/324.torrent'
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=500)
def setUp(self):
self.port = get_random_port()
self.server = None
self.should_call_new_version_callback = False
self.new_version_called = False
versioncheck_manager.VERSION_CHECK_URL = 'http://localhost:%s' % self.port
yield super(TestVersionCheck, self).setUp()
self.session.notifier.notify = self.notifier_callback
def setUpPreSession(self):
super(AbstractBaseApiTest, self).setUpPreSession()
self.config.set_http_api_enabled(True)
self.config.set_http_api_retry_port(True)
self.config.set_tunnel_community_enabled(False)
# Make sure we select a random port for the HTTP API
min_base_port = 1000 if not os.environ.get("TEST_BUCKET", None) \
else int(os.environ['TEST_BUCKET']) * 2000 + 2000
self.config.set_http_api_port(get_random_port(min_port=min_base_port, max_port=min_base_port + 2000))
def setUpPreSession(self):
super(AbstractBaseApiTest, self).setUpPreSession()
self.config.set_http_api_enabled(True)
self.config.set_megacache_enabled(True)
self.config.set_tunnel_community_enabled(False)
# Make sure we select a random port for the HTTP API
min_base_port = 1000 if not os.environ.get("TEST_BUCKET", None) \
else int(os.environ['TEST_BUCKET']) * 2000 + 2000
self.config.set_http_api_port(get_random_port(min_port=min_base_port, max_port=min_base_port + 2000))
def setUp(self):
self.port = get_random_port()
self.server = None
self.should_call_new_version_callback = False
self.new_version_called = False
versioncheck_manager.VERSION_CHECK_URL = 'http://localhost:%s' % self.port
yield super(TestVersionCheck, self).setUp()
self.session.lm.version_check_manager = VersionCheckManager(self.session)
self.session.notifier.notify = self.notifier_callback
def test_download_torrent_from_url(self):
# Setup file server to serve torrent file
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE, os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
d = self.session.start_download_from_uri('http://localhost:%s/ubuntu.torrent' % file_server_port)
d.addCallback(self.on_download)
return self.test_deferred
def test_client_server(self):
got_callback = Event()
line_callback = [None]
def readline_callback(socket, line):
line_callback[0] = line
got_callback.set()
port = get_random_port()
self.i2i_server = Instance2InstanceServer(port, readline_callback)
self.i2i_cleint = Instance2InstanceClient(port, 'START', 'XYZ')
self.assertTrue(got_callback.wait(5), "did not received callback")
self.assertEqual('START XYZ', line_callback[0], "lines did not match")
def test_download_torrent_from_url(self):
# Setup file server to serve torrent file
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE,
os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
d = self.session.start_download_from_uri(
'http://localhost:%s/ubuntu.torrent' % file_server_port)
d.addCallback(self.on_download)
return self.test_deferred
def test_client_server(self):
got_callback = Event()
line_callback = [None]
def readline_callback(socket, line):
line_callback[0] = line
got_callback.set()
port = get_random_port()
self.i2i_server = Instance2InstanceServer(port, readline_callback)
self.i2i_cleint = Instance2InstanceClient(port, 'START', 'XYZ')
self.assertTrue(got_callback.wait(5), "did not received callback")
self.assertEqual('START XYZ', line_callback[0], "lines did not match")
def setUp(self):
"""
Setup the tests by creating the ChannelRssParser instance and initializing it.
"""
yield super(TestChannelRss, self).setUp()
self.channel_rss = ChannelRssParser(self.fake_session, self.fake_channel_community, 'a')
self.channel_rss.initialize()
# Setup a test rss file server
test_rss_file = os.path.join(TESTS_DATA_DIR, 'test_rss.xml')
files_path = os.path.join(self.session_base_dir, 'files')
os.mkdir(files_path)
shutil.copyfile(test_rss_file, os.path.join(files_path, 'test_rss.xml'))
self.file_server_port = get_random_port()
self.setUpFileServer(self.file_server_port, files_path)
def prepare_xml_rss(target_path, filename):
"""
Function to prepare test_rss.xml file, replace the port with a random one
"""
files_path = os.path.join(target_path, 'http_torrent_files')
os.mkdir(files_path)
port = get_random_port()
from Tribler.Test.common import TESTS_DATA_DIR
with open(os.path.join(TESTS_DATA_DIR, filename), 'r') as source_xml,\
open(os.path.join(target_path, filename), 'w') as destination_xml:
for line in source_xml:
destination_xml.write(line.replace('RANDOMPORT', str(port)))
return files_path, port
def test_add_torrent_from_url(self):
"""
Test whether we can add a torrent to your channel from an URL
"""
self.create_my_channel()
# Setup file server to serve torrent file
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE, os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
self.should_check_equality = False
post_params = {'uri': 'http://localhost:%d/ubuntu.torrent' % file_server_port}
return self.do_request('mychannel/torrents', request_type='PUT', post_data=post_params, expected_code=200)
def prepare_xml_rss(target_path, filename):
"""
Function to prepare test_rss.xml file, replace the port with a random one
"""
files_path = os.path.join(target_path, 'http_torrent_files')
os.mkdir(files_path)
port = get_random_port()
from Tribler.Test.common import TESTS_DATA_DIR
with open(os.path.join(TESTS_DATA_DIR, filename), 'r') as source_xml,\
open(os.path.join(target_path, filename), 'w') as destination_xml:
for line in source_xml:
destination_xml.write(line.replace('RANDOMPORT', str(port)))
return files_path, port
def test_parse(self):
test_rss_file = os.path.join(TESTS_DATA_DIR, 'test_rss.xml')
files_path = os.path.join(self.session_base_dir, 'files')
os.mkdir(files_path)
shutil.copyfile(test_rss_file, os.path.join(files_path, 'test_rss.xml'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
parser = RSSFeedParser()
cache = SimpleCache(os.path.join(self.session_base_dir, 'cache.txt'))
cache.add('http://localhost:RANDOMPORT/ubuntu.torrent')
def on_items(rss_items):
self.assertEqual(len(rss_items), 2)
self.assertEqual(len(rss_items[0]['thumbnail_list']), 1)
return parser.parse('http://localhost:%d/test_rss.xml' % file_server_port, cache).addCallback(on_items)
def test_http_get_with_redirect(self):
"""
Test if http_get is working properly if url redirects to a magnet link.
"""
def on_callback(response):
self.assertEqual(response, magnet_link)
# Setup a redirect server which redirects to a magnet link
magnet_link = "magnet:?xt=urn:btih:DC4B96CF85A85CEEDB8ADC4B96CF85A85CEEDB8A"
port = get_random_port()
self.setUpHttpRedirectServer(port, magnet_link)
test_url = "http://localhost:%d" % port
http_deferred = http_get(test_url).addCallback(on_callback)
return http_deferred
def test_load_from_url_404(self):
# Setup file server to serve torrent file
self.session_base_dir = mkdtemp(suffix="_tribler_test_load_from_url")
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
# Do not copy the torrent file to produce 404
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
def _on_error(failure):
failure.trap(HttpError)
self.assertEqual(failure.value.response.code, 404)
torrent_url = 'http://localhost:%d/ubuntu.torrent' % file_server_port
deferred = TorrentDef.load_from_url(torrent_url)
deferred.addErrback(_on_error)
return deferred
def test_http_get_with_redirect(self):
"""
Test if http_get is working properly if url redirects to a magnet link.
"""
def on_callback(response):
self.assertEqual(response, magnet_link)
# Setup a redirect server which redirects to a magnet link
magnet_link = "magnet:?xt=urn:btih:DC4B96CF85A85CEEDB8ADC4B96CF85A85CEEDB8A"
port = get_random_port()
self.setUpHttpRedirectServer(port, magnet_link)
test_url = "http://localhost:%d" % port
http_deferred = http_get(test_url).addCallback(on_callback)
return http_deferred
def test_load_from_url_404(self):
# Setup file server to serve torrent file
self.session_base_dir = mkdtemp(suffix="_tribler_test_load_from_url")
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
# Do not copy the torrent file to produce 404
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
def _on_error(failure):
failure.trap(HttpError)
self.assertEqual(failure.value.response.code, 404)
torrent_url = 'http://localhost:%d/ubuntu.torrent' % file_server_port
deferred = TorrentDef.load_from_url(torrent_url)
deferred.addErrback(_on_error)
return deferred
def test_load_from_url(self):
# Setup file server to serve torrent file
self.session_base_dir = mkdtemp(suffix="_tribler_test_load_from_url")
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE, os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
def _on_load(torrent_def):
torrent_def.metainfo = create_valid_metainfo(torrent_def.get_metainfo())
self.assertTrue(valid_torrent_file(torrent_def.get_metainfo()))
self.assertEqual(torrent_def.get_metainfo(), TorrentDef.load(TORRENT_UBUNTU_FILE).get_metainfo())
self.assertEqual(torrent_def.infohash, TorrentDef.load(TORRENT_UBUNTU_FILE).infohash)
torrent_url = 'http://localhost:%d/ubuntu.torrent' % file_server_port
deferred = TorrentDef.load_from_url(torrent_url)
deferred.addCallback(_on_load)
return deferred
def test_add_torrent_from_url(self):
"""
Test whether we can add a torrent to your channel from an URL
"""
self.create_my_channel()
# Setup file server to serve torrent file
files_path = os.path.join(self.session_base_dir, 'http_torrent_files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE,
os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
self.should_check_equality = False
post_params = {
'uri': 'http://localhost:%d/ubuntu.torrent' % file_server_port
}
return self.do_request('mychannel/torrents',
request_type='PUT',
post_data=post_params,
expected_code=200)
def test_get_random_port_tcp(self):
rand_port_num = random.randint(*self.get_bucket_range_port())
listenport = reactor.listenTCP(rand_port_num, Factory())
random_port = get_random_port(socket_type='tcp', min_port=rand_port_num, max_port=rand_port_num)
self.assertGreaterEqual(random_port, rand_port_num+1)
return listenport.stopListening()
def test_get_random_port_udp(self):
random_port = get_random_port(socket_type='udp')
self.assertIsInstance(random_port, int)
self.assertTrue(random_port)
from random import randint
from unittest import skipUnless
from PyQt5.QtCore import QPoint, Qt, QTimer
from PyQt5.QtGui import QPixmap, QRegion
from PyQt5.QtTest import QTest
from PyQt5.QtWidgets import QApplication, QListWidget, QTreeWidget, QTextEdit
import TriblerGUI.core_manager as core_manager
import TriblerGUI.defs as gui_defs
from Tribler.Core.Utilities.network_utils import get_random_port
from TriblerGUI.dialogs.feedbackdialog import FeedbackDialog
from TriblerGUI.widgets.channel_torrent_list_item import ChannelTorrentListItem
from TriblerGUI.widgets.home_recommended_item import HomeRecommendedItem
rand_port = get_random_port()
core_manager.START_FAKE_API = True
gui_defs.API_PORT = rand_port
import TriblerGUI
from TriblerGUI.widgets.loading_list_item import LoadingListItem
from TriblerGUI.tribler_window import TriblerWindow
if os.environ.get("TEST_GUI") == "yes":
app = QApplication(sys.argv)
window = TriblerWindow()
QTest.qWaitForWindowExposed(window)
else:
window = None
def test_get_torrentinfo(self):
"""
Testing whether the API returns a correct dictionary with torrent info.
"""
# We intentionally put the file path in a folder with a:
# - "+" which is a reserved URI character
# - "\u0191" which is a unicode character
files_path = os.path.join(self.session_base_dir, u'http_torrent_+\u0191files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE, os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
def verify_valid_dict(data):
metainfo_dict = json.loads(data, encoding='latin_1')
self.assertTrue('metainfo' in metainfo_dict)
self.assertTrue('info' in metainfo_dict['metainfo'])
self.should_check_equality = False
yield self.do_request('torrentinfo', expected_code=400)
yield self.do_request('torrentinfo?uri=def', expected_code=400)
path = "file:" + pathname2url(os.path.join(TESTS_DATA_DIR, "bak_single.torrent")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
# Corrupt file
path = "file:" + pathname2url(os.path.join(TESTS_DATA_DIR, "test_rss.xml")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=500)
path = "http://localhost:%d/ubuntu.torrent" % file_server_port
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
def get_metainfo(infohash, callback, **_):
with open(os.path.join(TESTS_DATA_DIR, "bak_single.torrent"), mode='rb') as torrent_file:
torrent_data = torrent_file.read()
tdef = TorrentDef.load_from_memory(torrent_data)
callback(tdef.get_metainfo())
def get_metainfo_timeout(*args, **kwargs):
timeout_cb = kwargs.get('timeout_callback')
timeout_cb('a' * 20)
path = 'magnet:?xt=urn:btih:%s&dn=%s' % (hexlify(UBUNTU_1504_INFOHASH), quote_plus('test torrent'))
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = get_metainfo
self.session.lm.ltmgr.shutdown = lambda: None
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict) # Cached
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict) # Cached
# mdblob file
path_blob = "file:" + pathname2url(os.path.join(TESTS_DATA_DIR, "channel.mdblob")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path_blob, expected_code=200).addCallback(verify_valid_dict)
# invalid mdblob file
path_blob = "file:" + pathname2url(os.path.join(TESTS_DATA_DIR, "bad.mdblob")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path_blob, expected_code=500)
# non-torrent mdblob file
path_blob = "file:" + pathname2url(os.path.join(TESTS_DATA_DIR, "delete.mdblob")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path_blob, expected_code=500)
self.session.get_collected_torrent = lambda _: 'a8fdsafsdjlfdsafs{}{{{[][]][' # invalid torrent file
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=500)
path = 'magnet:?xt=urn:ed2k:354B15E68FB8F36D7CD88FF94116CDC1' # No infohash
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=400)
path = 'magnet:?xt=urn:btih:%s&dn=%s' % ('a' * 40, quote_plus('test torrent'))
self.session.lm.ltmgr.get_metainfo = get_metainfo_timeout
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=408)
def mocked_save_torrent(*_):
raise TypeError()
self.session.lm.ltmgr.get_metainfo = get_metainfo
self.session.save_collected_torrent = mocked_save_torrent
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
path = 'http://fdsafksdlafdslkdksdlfjs9fsafasdf7lkdzz32.n38/324.torrent'
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=500)
from unittest import skipUnless, skipIf
import time
from PyQt5.QtCore import QPoint, Qt, QTimer
from PyQt5.QtGui import QPixmap, QRegion
from PyQt5.QtTest import QTest
from PyQt5.QtWidgets import QApplication, QListWidget, QTreeWidget, QTextEdit
import TriblerGUI.core_manager as core_manager
import TriblerGUI.defs
from Tribler.Core.Utilities.network_utils import get_random_port
from TriblerGUI.dialogs.feedbackdialog import FeedbackDialog
from TriblerGUI.widgets.channel_torrent_list_item import ChannelTorrentListItem
from TriblerGUI.widgets.home_recommended_item import HomeRecommendedItem
api_port = get_random_port()
core_manager.START_FAKE_API = True
import TriblerGUI
TriblerGUI.defs.DEFAULT_API_PORT = api_port
from TriblerGUI.widgets.loading_list_item import LoadingListItem
from TriblerGUI.tribler_window import TriblerWindow
if os.environ.get("TEST_GUI") == "yes":
app = QApplication(sys.argv)
window = TriblerWindow(api_port=api_port)
QTest.qWaitForWindowExposed(window)
else:
window = None
def setUp(self):
TriblerCoreTest.setUp(self)
self.mock_session = MockObject()
self.video_server = VideoServer(get_random_port(), self.mock_session)
def test_get_random_port_invalid_type(self):
get_random_port(socket_type="http")
def test_get_random_port_udp(self):
random_port = get_random_port(socket_type='udp')
self.assertIsInstance(random_port, int)
self.assertTrue(random_port)
def _get_random_port(self, path):
"""Get a random port which is not already selected."""
if path not in self.selected_ports:
self.selected_ports[path] = get_random_port()
self._logger.debug(u"Get random port %d for [%s]", self.selected_ports[path], path)
return self.selected_ports[path]
def test_get_random_port(self):
random_port = get_random_port()
self.assertIsInstance(random_port, int)
self.assertTrue(random_port)
def test_get_random_port(self):
random_port = get_random_port()
self.assertIsInstance(random_port, int)
self.assertTrue(random_port)
def setUp(self, annotate=True):
yield super(TestSocks5Server, self).setUp(annotate=annotate)
self.socks5_server = Socks5Server(get_random_port(), None)
def test_get_torrentinfo(self):
"""
Testing whether the API returns a correct dictionary with torrent info.
"""
# We intentionally put the file path in a folder with a:
# - "+" which is a reserved URI character
# - "\u0191" which is a unicode character
files_path = os.path.join(self.session_base_dir, u'http_torrent_+\u0191files')
os.mkdir(files_path)
shutil.copyfile(TORRENT_UBUNTU_FILE, os.path.join(files_path, 'ubuntu.torrent'))
file_server_port = get_random_port()
self.setUpFileServer(file_server_port, files_path)
def verify_valid_dict(data):
json_data = json.loads(data)
metainfo_dict = json.loads(unhexlify(json_data['metainfo']), encoding='latin-1')
self.assertTrue('info' in metainfo_dict)
self.should_check_equality = False
yield self.do_request('torrentinfo', expected_code=400)
yield self.do_request('torrentinfo?uri=def', expected_code=400)
path = "file:" + pathname2url(os.path.join(TESTS_DATA_DIR, "bak_single.torrent")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
# Corrupt file
path = "file:" + pathname2url(os.path.join(TESTS_DATA_DIR, "test_rss.xml")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=500)
path = "http://localhost:%d/ubuntu.torrent" % file_server_port
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
def get_metainfo(infohash, callback, **_):
with open(os.path.join(TESTS_DATA_DIR, "bak_single.torrent"), mode='rb') as torrent_file:
torrent_data = torrent_file.read()
tdef = TorrentDef.load_from_memory(torrent_data)
callback(tdef.get_metainfo())
def get_metainfo_timeout(*args, **kwargs):
timeout_cb = kwargs.get('timeout_callback')
timeout_cb('a' * 20)
path = 'magnet:?xt=urn:btih:%s&dn=%s' % (hexlify(UBUNTU_1504_INFOHASH), quote_plus('test torrent'))
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = get_metainfo
self.session.lm.ltmgr.shutdown = lambda: None
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
# mdblob file
path_blob = "file:" + pathname2url(os.path.join(SAMPLE_CHANNEL_FILES_DIR, "channel.mdblob")).encode('utf-8')
yield self.do_request('torrentinfo?uri=%s' % path_blob, expected_code=200).addCallback(verify_valid_dict)
path = 'magnet:?xt=urn:ed2k:354B15E68FB8F36D7CD88FF94116CDC1' # No infohash
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=400)
path = 'magnet:?xt=urn:btih:%s&dn=%s' % ('a' * 40, quote_plus('test torrent'))
self.session.lm.ltmgr.get_metainfo = get_metainfo_timeout
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=408)
self.session.lm.ltmgr.get_metainfo = get_metainfo
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=200).addCallback(verify_valid_dict)
path = 'http://fdsafksdlafdslkdksdlfjs9fsafasdf7lkdzz32.n38/324.torrent'
yield self.do_request('torrentinfo?uri=%s' % path, expected_code=500)
def _get_random_port(self, path):
if path not in self.selected_ports:
self.selected_ports[path] = get_random_port()
self._logger.debug(u"Get random port %d for [%s]", self.selected_ports[path], path)
return self.selected_ports[path]
def setUp(self, annotate=True):
TriblerCoreTest.setUp(self, annotate=annotate)
self.mock_session = MockObject()
self.video_server = VideoServer(get_random_port(), self.mock_session)
from unittest import skipUnless, skipIf
import time
from PyQt5.QtCore import QPoint, Qt, QTimer
from PyQt5.QtGui import QPixmap, QRegion
from PyQt5.QtTest import QTest
from PyQt5.QtWidgets import QApplication, QListWidget, QTreeWidget, QTextEdit
import TriblerGUI.core_manager as core_manager
import TriblerGUI.defs
from Tribler.Core.Utilities.network_utils import get_random_port
from TriblerGUI.dialogs.feedbackdialog import FeedbackDialog
from TriblerGUI.widgets.channel_torrent_list_item import ChannelTorrentListItem
from TriblerGUI.widgets.home_recommended_item import HomeRecommendedItem
api_port = get_random_port()
core_manager.START_FAKE_API = True
import TriblerGUI
TriblerGUI.defs.DEFAULT_API_PORT = api_port
from TriblerGUI.widgets.loading_list_item import LoadingListItem
from TriblerGUI.tribler_window import TriblerWindow
if os.environ.get("TEST_GUI") == "yes":
app = QApplication(sys.argv)
window = TriblerWindow(api_port=api_port)
QTest.qWaitForWindowExposed(window)
else:
window = None
def test_get_random_port_invalid_type(self):
get_random_port(socket_type="http")
def _get_random_port(self, path):
if path not in self.selected_ports:
self.selected_ports[path] = get_random_port()
self._logger.debug(u"Get random port %d for [%s]",
self.selected_ports[path], path)
return self.selected_ports[path]
def setUp(self):
yield super(TestSocks5Server, self).setUp()
self.socks5_server = Socks5Server(get_random_port(), None)
