def verify_response_no_trackers(response):
json_response = json.loads(response)
expected_dict = {u"health":
{u"DHT":
{u"leechers": 11, u"seeders": 12,
u"infohash": unicode(tdef.infohash.encode('hex'))}}}
self.assertDictEqual(json_response, expected_dict)
def verify_settings(result):
result_json = json.loads(result)
settings_json = result_json['settings']
self.assertEqual(result_json['hop'], hop)
self.assertTrue("libtorrent" in settings_json['user_agent'])
self.assertEqual(settings_json['outgoing_port'], 0)
self.assertEqual(settings_json['num_outgoing_ports'], 1)
def on_finished(self, reply, capture_errors):
self.status_code = reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute)
request_queue.parse_queue()
if not reply.isOpen() or not self.status_code:
self.received_json.emit(None, reply.error())
return
data = reply.readAll()
try:
json_result = json.loads(str(data), encoding='latin_1')
if 'error' in json_result and capture_errors:
self.show_error(
TriblerRequestManager.get_message_from_error(json_result))
else:
self.received_json.emit(json_result, reply.error())
except ValueError:
self.received_json.emit(None, reply.error())
logging.error("No json object could be decoded from data: %s" %
data)
# We disconnect the slot since we want the finished only to be emitted once. This allows us to reuse the
# request manager.
try:
self.finished.disconnect()
self.received_json.disconnect()
except TypeError:
pass # We probably didn't have any connected slots.
def verify_delete_response(response):
json_response = json.loads(response)
self.assertFalse(json_response["removed"],
"Tribler removed an unknown torrent")
self.assertTrue(
unknown_torrent_infohash in json_response["failed_torrents"])
self.assertFalse(mock_channel_community.called_remove)
def render_POST(self, request):
"""
.. http:post:: /settings
A POST request to this endpoint will update Tribler settings. A JSON-dictionary should be passed as body
contents.
**Example request**:
.. sourcecode:: none
curl -X POST http://localhost:8085/settings --data "{"
**Example response**:
.. sourcecode:: javascript
{
"modified": True
}
"""
settings_dict = json.loads(request.content.read(), encoding='latin_1')
self.parse_settings_dict(settings_dict)
self.session.config.write()
return json.dumps({"modified": True})
def parse_body(body):
if body is None:
return
version = json.loads(body)['name'][1:]
if LooseVersion(version) > LooseVersion(version_id):
self.session.notifier.notify(NTFY_NEW_VERSION, NTFY_INSERT,
None, version)
def verify_settings(result):
result_json = json.loads(result)
settings_json = result_json['settings']
self.assertEqual(result_json['hop'], hop)
self.assertTrue("libtorrent" in settings_json['user_agent'])
self.assertEqual(settings_json['outgoing_port'], 0)
self.assertEqual(settings_json['num_outgoing_ports'], 1)
def on_finished(self, reply, capture_errors):
self.status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
request_queue.parse_queue()
if not reply.isOpen() or not self.status_code:
self.received_json.emit(None, reply.error())
return
data = reply.readAll()
try:
json_result = json.loads(str(data), encoding='latin_1')
if 'error' in json_result and capture_errors:
self.show_error(TriblerRequestManager.get_message_from_error(json_result))
else:
self.received_json.emit(json_result, reply.error())
except ValueError:
self.received_json.emit(None, reply.error())
logging.error("No json object could be decoded from data: %s" % data)
# We disconnect the slot since we want the finished only to be emitted once. This allows us to reuse the
# request manager.
try:
reply.finished.disconnect()
self.received_json.disconnect()
except TypeError:
pass # We probably didn't have any connected slots.
try:
reply.deleteLater()
except RuntimeError:
pass
self.reply = None
def verify_channel_created(body):
channel_obj = self.session.lm.channel_manager._channel_list[0]
self.assertEqual(channel_obj.name, post_data["name"])
self.assertEqual(channel_obj.description, post_data["description"])
self.assertEqual(channel_obj.mode, u'closed')
self.assertDictEqual(json.loads(body),
{"added": channel_obj.channel_id})
def verify_channels(channels):
channels_json = json.loads(channels)['channels']
self.assertEqual(len(channels_json), 10)
channels_json = sorted(channels_json,
key=lambda channel: channel['name'])
for ind in xrange(len(channels_json)):
self.assertEqual(channels_json[ind]['name'],
'Test channel %d' % ind)
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(len(response_json['circuits']), 1)
self.assertEqual(response_json['circuits'][0]['state'], 'TESTSTATE')
self.assertEqual(response_json['circuits'][0]['bytes_up'], 200)
self.assertEqual(response_json['circuits'][0]['bytes_down'], 400)
self.assertEqual(len(response_json['circuits'][0]['hops']), 1)
self.assertEqual(response_json['circuits'][0]['hops'][0]['host'], 'somewhere:4242')
def verify_download(response):
self.assertTrue(json.loads(response)['started'])
self.assertGreaterEqual(len(self.session.get_downloads()), 1)
dl = self.session.get_downloads()[0]
dl.tracker_status[u"\u266b"] = [0, 'Not contacted yet']
tdef = dl.get_def()
tdef.input['name'] = u'video\u266b'
return self.do_request('downloads?get_peers=1&get_pieces=1', expected_code=200)
def verify_download_list(response):
response_dict = json.loads(response)
self.assertIn("downloads", response_dict)
self.assertEqual(1, len(response_dict["downloads"]))
self.assertIn("peers", response_dict["downloads"][0])
self.assertEqual(1, len(response_dict["downloads"][0]["peers"]))
self.assertNotIn('have', response_dict["downloads"][0]["peers"][0])
self.assertEqual(u'', response_dict["downloads"][0]["peers"][0]['extended_version'])
def verify_download_list(response):
response_dict = json.loads(response)
self.assertIn("downloads", response_dict)
self.assertEqual(1, len(response_dict["downloads"]))
self.assertIn("peers", response_dict["downloads"][0])
self.assertEqual(1, len(response_dict["downloads"][0]["peers"]))
self.assertNotIn('have', response_dict["downloads"][0]["peers"][0])
self.assertEqual(u'', response_dict["downloads"][0]["peers"][0]['extended_version'])
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(len(response_json['circuits']), 1)
self.assertEqual(response_json['circuits'][0]['state'], 'TESTSTATE')
self.assertEqual(response_json['circuits'][0]['bytes_up'], 200)
self.assertEqual(response_json['circuits'][0]['bytes_down'], 400)
self.assertEqual(len(response_json['circuits'][0]['hops']), 1)
self.assertEqual(response_json['circuits'][0]['hops'][0]['host'], 'somewhere:4242')
def verify_download(downloads):
downloads_json = json.loads(downloads)
self.assertEqual(len(downloads_json['downloads']), 2)
self.assertEqual(downloads_json['downloads'][0][u'files'],
[{u'included': True, u'index': 0, u'size': 1583233,
u'name': u'Tribler_4.1.7_src.zip', u'progress': 0.0}])
self.assertEqual(downloads_json['downloads'][1][u'files'],
[{u'included': True, u'index': 0, u'size': 1942100,
u'name': u'video.avi', u'progress': 0.0}])
def verify_download(downloads):
downloads_json = json.loads(downloads)
self.assertEqual(len(downloads_json['downloads']), 2)
self.assertEqual(downloads_json['downloads'][0][u'files'],
[{u'included': True, u'index': 0, u'size': 1583233,
u'name': u'Tribler_4.1.7_src.zip', u'progress': 0.0}])
self.assertEqual(downloads_json['downloads'][1][u'files'],
[{u'included': True, u'index': 0, u'size': 1942100,
u'name': u'video.avi', u'progress': 0.0}])
def verify_download(response):
self.assertTrue(json.loads(response)['started'])
self.assertGreaterEqual(len(self.session.get_downloads()), 1)
dl = self.session.get_downloads()[0]
dl.tracker_status[u"\u266b"] = [0, 'Not contacted yet']
tdef = dl.get_def()
tdef.input['name'] = u'video\u266b'
return self.do_request('downloads?get_peers=1&get_pieces=1',
expected_code=200)
def verify_playlists(results):
json_result = json.loads(results)
self.assertTrue('playlists' in json_result)
self.assertEqual(len(json_result['playlists']), 1)
self.assertTrue('torrents' in json_result['playlists'][0])
self.assertEqual(len(json_result['playlists'][0]['torrents']), 1)
torrent = json_result['playlists'][0]['torrents'][0]
self.assertEqual(torrent['infohash'], 'a' * 40)
self.assertEqual(torrent['name'], 'ubuntu-torrent.iso')
def verify_playlists(results):
json_result = json.loads(results)
self.assertTrue('playlists' in json_result)
self.assertEqual(len(json_result['playlists']), 1)
self.assertTrue('torrents' in json_result['playlists'][0])
self.assertEqual(len(json_result['playlists'][0]['torrents']), 1)
torrent = json_result['playlists'][0]['torrents'][0]
self.assertEqual(torrent['infohash'], 'a' * 40)
self.assertEqual(torrent['name'], 'ubuntu-torrent.iso')
def verify_download(response):
self.assertTrue(json.loads(response)['started'])
self.assertGreaterEqual(len(self.session.get_downloads()), 1)
dl = self.session.get_downloads()[0]
ds = DownloadState(dl, self.create_mock_status(), None)
ds.get_peerlist = lambda: [{'id': '1234', 'have': '5678', 'extended_version': None}]
dl.get_state = lambda: ds
self.should_check_equality = False
return self.do_request('downloads?get_peers=1&get_pieces=1',
expected_code=200).addCallback(verify_download_list)
def verify_error_message(body):
error_response = json.loads(body)
expected_response = {
u"error": {
u"handled": True,
u"code": u"IOError",
u"message": u"Path does not exist: %s" % post_data["files[]"]
}
}
self.assertDictContainsSubset(expected_response[u"error"], error_response[u"error"])
def verify_error_message(body):
error_response = json.loads(body)
expected_response = {
u"error": {
u"handled": False,
u"code": u"Exception",
u"message": u"Tribler is shutting down"
}
}
self.assertDictContainsSubset(expected_response[u"error"], error_response[u"error"])
def verify_download(response):
self.assertTrue(json.loads(response)['started'])
self.assertGreaterEqual(len(self.session.get_downloads()), 1)
dl = self.session.get_downloads()[0]
ds = DownloadState(dl, self.create_mock_status(), None)
ds.get_peerlist = lambda: [{'id': '1234', 'have': '5678', 'extended_version': None}]
dl.get_state = lambda: ds
self.should_check_equality = False
return self.do_request('downloads?get_peers=1&get_pieces=1',
expected_code=200).addCallback(verify_download_list)
def verify_error_message(body):
error_response = json.loads(body)
expected_response = {
u"error": {
u"handled": True,
u"code": u"DuplicateChannelNameError",
u"message": u"Channel name already exists: %s" % post_data["name"]
}
}
self.assertDictContainsSubset(expected_response[u"error"], error_response[u"error"])
def verify_error_message(body):
error_response = json.loads(body)
expected_response = {
u"error": {
u"handled": True,
u"code": u"IOError",
u"message": u"Path does not exist: %s" % post_data["files"]
}
}
self.assertDictContainsSubset(expected_response[u"error"], error_response[u"error"])
def verify_error_message(body):
error_response = json.loads(body)
expected_response = {
u"error": {
u"handled": False,
u"code": u"TriblerException",
u"message": u"Oops! Something went wrong. Please restart Tribler"
}
}
self.assertDictContainsSubset(expected_response[u"error"], error_response[u"error"])
def verify_error_message(body):
error_response = json.loads(body)
expected_response = {
u"error": {
u"handled": True,
u"code": u"RuntimeError",
u"message": u"Metainfo timeout"
}
}
self.assertDictContainsSubset(expected_response[u"error"], error_response[u"error"])
def verify_response_with_trackers(response):
json_response = json.loads(response)
expected_dict = {u"health":
{u"DHT":
{u"leechers": 2, u"seeders": 1, u"infohash": (u'a' * 20).encode('hex')},
u"udp://localhost:%s" % self.udp_port:
{u"leechers": 20, u"seeders": 10, u"infohash": (u'a' * 20).encode('hex')},
u"http://localhost:%s/announce" % self.http_port:
{u"leechers": 30, u"seeders": 20, u"infohash": (u'a' * 20).encode('hex')}}}
self.assertDictEqual(json_response, expected_dict)
def verify_log_exists(response):
json_response = json.loads(response)
logs = json_response['content'].strip().split("\n")
# Check number of logs returned is correct
self.assertEqual(len(logs), max_lines)
# Check if test log message is present in the logs, at least once
log_exists = any((True for log in logs if test_core_log_message in log))
self.assertTrue(log_exists, "Test log not found in the debug log response")
def verify_log_exists(response):
json_response = json.loads(response)
logs = json_response['content'].strip().split("\n")
# Check number of logs returned is correct
self.assertEqual(len(logs), max_lines)
# Check if test log message is present in the logs, at least once
log_exists = any((True for log in logs if test_log_message in log))
self.assertTrue(log_exists, "Test log not found in the debug log response")
def on_read_data(self):
if self.receivers(self.finished) == 0:
self.finished.connect(lambda reply: self.on_finished())
self.connect_timer.stop()
data = self.reply.readAll()
self.current_event_string += data
if len(self.current_event_string
) > 0 and self.current_event_string[-1] == '\n':
for event in self.current_event_string.split('\n'):
if len(event) == 0:
continue
json_dict = json.loads(str(event))
received_events.insert(0, (json_dict, time.time()))
if len(received_events
) > 100: # Only buffer the last 100 events
received_events.pop()
if json_dict["type"] == "search_result_channel":
self.received_search_result_channel.emit(
json_dict["event"]["result"])
elif json_dict["type"] == "search_result_torrent":
self.received_search_result_torrent.emit(
json_dict["event"]["result"])
elif json_dict[
"type"] == "tribler_started" and not self.emitted_tribler_started:
self.tribler_started.emit()
self.emitted_tribler_started = True
elif json_dict["type"] == "new_version_available":
self.new_version_available.emit(
json_dict["event"]["version"])
elif json_dict["type"] == "upgrader_started":
self.upgrader_started.emit()
elif json_dict["type"] == "upgrader_finished":
self.upgrader_finished.emit()
elif json_dict["type"] == "upgrader_tick":
self.upgrader_tick.emit(json_dict["event"]["text"])
elif json_dict["type"] == "channel_discovered":
self.discovered_channel.emit(json_dict["event"])
elif json_dict["type"] == "torrent_discovered":
self.discovered_torrent.emit(json_dict["event"])
elif json_dict["type"] == "events_start":
self.tribler_version = json_dict["event"]["version"]
if json_dict["event"][
"tribler_started"] and not self.emitted_tribler_started:
self.tribler_started.emit()
self.emitted_tribler_started = True
elif json_dict["type"] == "torrent_finished":
self.torrent_finished.emit(json_dict["event"])
elif json_dict["type"] == "signal_low_space":
self.low_storage_signal.emit(json_dict["event"])
elif json_dict["type"] == "tribler_exception":
raise RuntimeError(json_dict["event"]["text"])
self.current_event_string = ""
def verify_torrent(body):
response = json.loads(body)
torrent = base64.b64decode(response["torrent"])
tdef = TorrentDef.load_from_memory(torrent)
# Copy expected creation date and created by (Tribler version) from actual result
creation_date = tdef.get_creation_date()
expected_tdef.metainfo["creation date"] = creation_date
expected_tdef.metainfo["created by"] = tdef.metainfo['created by']
self.assertEqual(dir(expected_tdef), dir(tdef))
def verify_torrent(body):
response = json.loads(body)
torrent = base64.b64decode(response["torrent"])
tdef = TorrentDef.load_from_memory(torrent)
# Copy expected creation date and created by (Tribler version) from actual result
creation_date = tdef.get_creation_date()
expected_tdef.metainfo["creation date"] = creation_date
expected_tdef.metainfo["created by"] = tdef.metainfo['created by']
self.assertEqual(dir(expected_tdef), dir(tdef))
def verify_settings(self, settings):
"""
Verify that the expected sections are present.
"""
check_section = ['libtorrent', 'mainline_dht', 'torrent_store', 'general', 'torrent_checking',
'allchannel_community', 'tunnel_community', 'http_api', 'torrent_collecting', 'dispersy',
'trustchain', 'watch_folder', 'search_community', 'metadata']
settings_json = json.loads(settings)
self.assertTrue(settings_json['settings'])
for section in check_section:
self.assertTrue(settings_json['settings'][section])
def verify_response_no_trackers(response):
json_response = json.loads(response)
expected_dict = {
u"health": {
u"DHT": {
u"leechers": 11,
u"seeders": 12,
u"infohash": unicode(tdef.infohash.encode('hex'))
}
}
}
self.assertDictEqual(json_response, expected_dict)
def verify_settings(self, settings):
"""
Verify that the expected sections are present.
"""
check_section = ['libtorrent', 'general', 'torrent_checking',
'tunnel_community', 'http_api', 'trustchain', 'watch_folder']
settings_json = json.loads(settings)
self.assertTrue(settings_json['settings'])
self.assertTrue(settings_json['ports'])
for section in check_section:
self.assertTrue(settings_json['settings'][section])
def on_received_metainfo(self, metainfo):
if not metainfo or not self:
return
if 'error' in metainfo:
if metainfo['error'] == 'timeout':
self.dialog_widget.loading_files_label.setText(
"Timeout when trying to fetch files.")
elif 'code' in metainfo['error'] and metainfo['error'][
'code'] == 'IOError':
self.dialog_widget.loading_files_label.setText(
"Unable to read torrent file data")
else:
self.dialog_widget.loading_files_label.setText(
"Error: %s" % metainfo['error'])
return
metainfo = json.loads(unhexlify(metainfo['metainfo']),
encoding='latin-1')
if 'files' in metainfo['info']: # Multi-file torrent
files = metainfo['info']['files']
else:
files = [{
'path': [metainfo['info']['name']],
'length': metainfo['info']['length']
}]
# Show if the torrent already exists in the downloads
if 'download_exists' in metainfo and metainfo['download_exists']:
self.dialog_widget.existing_download_info_label.setText(
"Note: this torrent already exists in the Downloads")
else:
self.dialog_widget.existing_download_info_label.setText("")
for filename in files:
item = DownloadFileTreeWidgetItem(
self.dialog_widget.files_list_view)
item.setText(
0, '/'.join(filename['path']).encode('raw_unicode_escape'))
item.setText(1, format_size(float(filename['length'])))
item.setData(0, Qt.UserRole, filename)
item.setCheckState(2, Qt.Checked)
self.dialog_widget.files_list_view.addTopLevelItem(item)
self.has_metainfo = True
self.dialog_widget.loading_files_label.setHidden(True)
self.dialog_widget.download_files_container.setHidden(False)
self.dialog_widget.files_list_view.setHidden(False)
self.dialog_widget.adjustSize()
self.on_main_window_resize()
self.received_metainfo.emit(metainfo)
def verify_settings(self, settings):
"""
Verify that the expected sections are present.
"""
check_section = ['libtorrent', 'mainline_dht', 'torrent_store', 'general', 'torrent_checking',
'allchannel_community', 'tunnel_community', 'http_api', 'torrent_collecting', 'dispersy',
'trustchain', 'watch_folder', 'search_community', 'metadata']
settings_json = json.loads(settings)
self.assertTrue(settings_json['settings'])
self.assertTrue(settings_json['ports'])
for section in check_section:
self.assertTrue(settings_json['settings'][section])
def verify_error_message(body):
error_response = json.loads(body)
expected_response = {
u"error": {
u"handled":
True,
u"code":
u"DuplicateChannelNameError",
u"message":
u"Channel name already exists: %s" % post_data["name"]
}
}
self.assertDictContainsSubset(expected_response[u"error"],
error_response[u"error"])
def verify_download(response):
self.assertTrue(json.loads(response)['started'])
self.assertGreaterEqual(len(self.session.get_downloads()), 1)
dl = self.session.get_downloads()[0]
ds = DownloadState(dl, dl.dlstate, dl.error, 0.0)
ds.get_peerlist = lambda: [{
'id': '1234',
'have': '5678',
'extended_version': '\xb5Torrent 1.6.1'
}]
dl.network_get_state = lambda x, y: ds
self.should_check_equality = False
return self.do_request(
'downloads?get_peers=1&get_pieces=1',
expected_code=200).addCallback(verify_download_list)
def verify_response(response):
response_json = json.loads(response)
self.assertTrue("statistics" in response_json)
stats = response_json["statistics"]
self.assertEqual(
stats["self_id"],
base64.encodestring(self.member.public_key).strip())
self.assertEqual(stats["self_total_blocks"], -1)
self.assertEqual(stats["self_total_up_mb"], 0)
self.assertEqual(stats["self_total_down_mb"], 0)
self.assertEqual(stats["self_peers_helped"], 0)
self.assertEqual(stats["self_peers_helped_you"], 0)
self.assertEqual(stats["latest_block_insert_time"], "")
self.assertEqual(stats["latest_block_id"], "")
self.assertEqual(stats["latest_block_requester_id"], "")
self.assertEqual(stats["latest_block_responder_id"], "")
self.assertEqual(stats["latest_block_up_mb"], "")
self.assertEqual(stats["latest_block_down_mb"], "")
def verify_response_with_trackers(response):
json_response = json.loads(response)
expected_dict = {
u"health": {
u"DHT": {
u"leechers": 2,
u"seeders": 1,
u"infohash": (u'a' * 20).encode('hex')
},
u"udp://localhost:%s" % self.udp_port: {
u"leechers": 20,
u"seeders": 10,
u"infohash": (u'a' * 20).encode('hex')
},
u"http://localhost:%s/announce" % self.http_port: {
u"leechers": 30,
u"seeders": 20,
u"infohash": (u'a' * 20).encode('hex')
}
}
}
self.assertDictEqual(json_response, expected_dict)
def verify_response(response):
response_json = json.loads(response)
self.assertTrue("statistics" in response_json)
stats = response_json["statistics"]
self.assertEqual(
stats["self_id"],
base64.encodestring(self.member.public_key).strip())
self.assertEqual(stats["self_total_blocks"], 3)
self.assertEqual(stats["self_total_up_mb"], 1024)
self.assertEqual(stats["self_total_down_mb"], 2048)
self.assertEqual(stats["self_peers_helped"], 1)
self.assertEqual(stats["self_peers_helped_you"], 1)
self.assertNotEqual(stats["latest_block_insert_time"], "")
self.assertEqual(
stats["latest_block_id"],
base64.encodestring("b19b00b5".decode("HEX")).strip())
self.assertEqual(
stats["latest_block_requester_id"],
base64.encodestring(self.member.public_key).strip())
self.assertEqual(
stats["latest_block_responder_id"],
base64.encodestring("deadbeef".decode("HEX")).strip())
self.assertEqual(stats["latest_block_up_mb"], "42")
self.assertEqual(stats["latest_block_down_mb"], "8")
def parse_body(self, body):
if body is not None and self.should_check_equality:
self.assertDictEqual(self.expected_response_json, json.loads(body))
return body
def verify_response(response):
json_response = json.loads(response)
self.assertIn('state', json_response)
def verify_response(response):
response_json = json.loads(response)
self.assertEqual(len(response_json["slots"]["random"]), 4)
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['open_sockets']), 1)
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['threads']), 1)
def verify_response(response):
response_json = json.loads(response)
self.assertGreaterEqual(len(response_json['memory_history']), 1)
def dataReceived(self, data):
self._logger.info("Received data: %s" % data)
self.json_buffer.append(json.loads(data))
self.messages_to_wait_for -= 1
if self.messages_to_wait_for == 0:
self.response.loseConnection()
def parse_body(self, body):
if body is not None and self.should_check_equality:
self.assertDictEqual(self.expected_response_json, json.loads(body))
return body
def verify_dict(data):
json_data = json.loads(data)
self.assertTrue(json_data["dispersy_community_statistics"])
self.assertTrue(json_data["ipv8_overlay_statistics"])
def verify_dict(data):
self.assertFalse(json.loads(data)["ipv8_statistics"])
def verify_dict(data):
self.assertTrue(json.loads(data)["dispersy_statistics"])
def verify_dict(data):
self.assertTrue(json.loads(data)["tribler_statistics"])
def parse_body(body):
if body is None:
return
version = json.loads(body)['name'][1:]
if LooseVersion(version) > LooseVersion(version_id):
self.session.notifier.notify(NTFY_NEW_VERSION, NTFY_INSERT, None, version)
