class CoreTestCase(BaseTestCase):
def set_up(self):
common.set_tmp_config_dir()
self.rpcserver = RPCServer(listen=False)
self.core = Core()
self.core.config.config['lsd'] = False
self.clock = task.Clock()
self.core.torrentmanager.callLater = self.clock.callLater
self.listen_port = 51242
return component.start().addCallback(self.start_web_server)
def start_web_server(self, result):
website = Site(TopLevelResource())
for dummy in range(10):
try:
self.webserver = reactor.listenTCP(self.listen_port, website)
except CannotListenError as ex:
error = ex
self.listen_port += 1
else:
break
else:
raise error
return result
def tear_down(self):
def on_shutdown(result):
del self.rpcserver
del self.core
return self.webserver.stopListening()
return component.shutdown().addCallback(on_shutdown)
def add_torrent(self, filename, paused=False):
if not paused:
# Patch libtorrent flags starting torrents paused
self.patch(deluge.core.torrentmanager,
'LT_DEFAULT_ADD_TORRENT_FLAGS', 592)
options = {'add_paused': paused, 'auto_managed': False}
filepath = common.get_test_data_file(filename)
with open(filepath, 'rb') as _file:
filedump = b64encode(_file.read())
torrent_id = self.core.add_torrent_file(filename, filedump, options)
return torrent_id
@defer.inlineCallbacks
def test_add_torrent_files(self):
options = {}
filenames = ['test.torrent', 'test_torrent.file.torrent']
files_to_add = []
for f in filenames:
filename = common.get_test_data_file(f)
with open(filename, 'rb') as _file:
filedump = b64encode(_file.read())
files_to_add.append((filename, filedump, options))
errors = yield self.core.add_torrent_files(files_to_add)
self.assertEqual(len(errors), 0)
@defer.inlineCallbacks
def test_add_torrent_files_error_duplicate(self):
options = {}
filenames = ['test.torrent', 'test.torrent']
files_to_add = []
for f in filenames:
filename = common.get_test_data_file(f)
with open(filename, 'rb') as _file:
filedump = b64encode(_file.read())
files_to_add.append((filename, filedump, options))
errors = yield self.core.add_torrent_files(files_to_add)
self.assertEqual(len(errors), 1)
self.assertTrue(
str(errors[0]).startswith('Torrent already in session'))
@defer.inlineCallbacks
def test_add_torrent_file(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = b64encode(_file.read())
torrent_id = yield self.core.add_torrent_file_async(
filename, filedump, options)
# Get the info hash from the test.torrent
from deluge.bencode import bdecode, bencode
with open(filename, 'rb') as _file:
info_hash = sha(bencode(bdecode(
_file.read())[b'info'])).hexdigest()
self.assertEqual(torrent_id, info_hash)
def test_add_torrent_file_invalid_filedump(self):
options = {}
filename = common.get_test_data_file('test.torrent')
self.assertRaises(AddTorrentError, self.core.add_torrent_file,
filename, False, options)
@defer.inlineCallbacks
def test_add_torrent_url(self):
url = ('http://localhost:%d/ubuntu-9.04-desktop-i386.iso.torrent' %
self.listen_port)
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
torrent_id = yield self.core.add_torrent_url(url, options)
self.assertEqual(torrent_id, info_hash)
def test_add_torrent_url_with_cookie(self):
url = 'http://localhost:%d/cookie' % self.listen_port
options = {}
headers = {'Cookie': 'password=deluge'}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallbacks(self.fail,
self.assertIsInstance,
errbackArgs=(Failure, ))
d = self.core.add_torrent_url(url, options, headers)
d.addCallbacks(self.assertEqual, self.fail, callbackArgs=(info_hash, ))
return d
def test_add_torrent_url_with_redirect(self):
url = 'http://localhost:%d/redirect' % self.listen_port
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEqual, info_hash)
return d
def test_add_torrent_url_with_partial_download(self):
url = 'http://localhost:%d/partial' % self.listen_port
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEqual, info_hash)
return d
@defer.inlineCallbacks
def test_add_torrent_magnet(self):
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
uri = deluge.common.create_magnet_uri(info_hash)
options = {}
torrent_id = yield self.core.add_torrent_magnet(uri, options)
self.assertEqual(torrent_id, info_hash)
def test_resume_torrent(self):
tid1 = self.add_torrent('test.torrent', paused=True)
tid2 = self.add_torrent('test_torrent.file.torrent', paused=True)
# Assert paused
r1 = self.core.get_torrent_status(tid1, ['paused'])
self.assertTrue(r1['paused'])
r2 = self.core.get_torrent_status(tid2, ['paused'])
self.assertTrue(r2['paused'])
self.core.resume_torrent(tid2)
r1 = self.core.get_torrent_status(tid1, ['paused'])
self.assertTrue(r1['paused'])
r2 = self.core.get_torrent_status(tid2, ['paused'])
self.assertFalse(r2['paused'])
def test_resume_torrent_list(self):
"""Backward compatibility for list of torrent_ids."""
torrent_id = self.add_torrent('test.torrent', paused=True)
self.core.resume_torrent([torrent_id])
result = self.core.get_torrent_status(torrent_id, ['paused'])
self.assertFalse(result['paused'])
def test_resume_torrents(self):
tid1 = self.add_torrent('test.torrent', paused=True)
tid2 = self.add_torrent('test_torrent.file.torrent', paused=True)
self.core.resume_torrents([tid1, tid2])
r1 = self.core.get_torrent_status(tid1, ['paused'])
self.assertFalse(r1['paused'])
r2 = self.core.get_torrent_status(tid2, ['paused'])
self.assertFalse(r2['paused'])
def test_resume_torrents_all(self):
"""With no torrent_ids param, resume all torrents"""
tid1 = self.add_torrent('test.torrent', paused=True)
tid2 = self.add_torrent('test_torrent.file.torrent', paused=True)
self.core.resume_torrents()
r1 = self.core.get_torrent_status(tid1, ['paused'])
self.assertFalse(r1['paused'])
r2 = self.core.get_torrent_status(tid2, ['paused'])
self.assertFalse(r2['paused'])
def test_pause_torrent(self):
tid1 = self.add_torrent('test.torrent')
tid2 = self.add_torrent('test_torrent.file.torrent')
# Assert not paused
r1 = self.core.get_torrent_status(tid1, ['paused'])
self.assertFalse(r1['paused'])
r2 = self.core.get_torrent_status(tid2, ['paused'])
self.assertFalse(r2['paused'])
self.core.pause_torrent(tid2)
r1 = self.core.get_torrent_status(tid1, ['paused'])
self.assertFalse(r1['paused'])
r2 = self.core.get_torrent_status(tid2, ['paused'])
self.assertTrue(r2['paused'])
def test_pause_torrent_list(self):
"""Backward compatibility for list of torrent_ids."""
torrent_id = self.add_torrent('test.torrent')
result = self.core.get_torrent_status(torrent_id, ['paused'])
self.assertFalse(result['paused'])
self.core.pause_torrent([torrent_id])
result = self.core.get_torrent_status(torrent_id, ['paused'])
self.assertTrue(result['paused'])
def test_pause_torrents(self):
tid1 = self.add_torrent('test.torrent')
tid2 = self.add_torrent('test_torrent.file.torrent')
self.core.pause_torrents([tid1, tid2])
r1 = self.core.get_torrent_status(tid1, ['paused'])
self.assertTrue(r1['paused'])
r2 = self.core.get_torrent_status(tid2, ['paused'])
self.assertTrue(r2['paused'])
def test_pause_torrents_all(self):
"""With no torrent_ids param, pause all torrents"""
tid1 = self.add_torrent('test.torrent')
tid2 = self.add_torrent('test_torrent.file.torrent')
self.core.pause_torrents()
r1 = self.core.get_torrent_status(tid1, ['paused'])
self.assertTrue(r1['paused'])
r2 = self.core.get_torrent_status(tid2, ['paused'])
self.assertTrue(r2['paused'])
def test_prefetch_metadata_existing(self):
"""Check another call with same magnet returns existing deferred."""
magnet = 'magnet:?xt=urn:btih:ab570cdd5a17ea1b61e970bb72047de141bce173'
expected = ('ab570cdd5a17ea1b61e970bb72047de141bce173', None)
def on_result(result):
self.assertEqual(result, expected)
d = self.core.prefetch_magnet_metadata(magnet)
d.addCallback(on_result)
d2 = self.core.prefetch_magnet_metadata(magnet)
d2.addCallback(on_result)
self.clock.advance(30)
return defer.DeferredList([d, d2])
@defer.inlineCallbacks
def test_remove_torrent(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = b64encode(_file.read())
torrent_id = yield self.core.add_torrent_file_async(
filename, filedump, options)
removed = self.core.remove_torrent(torrent_id, True)
self.assertTrue(removed)
self.assertEqual(len(self.core.get_session_state()), 0)
def test_remove_torrent_invalid(self):
self.assertRaises(
InvalidTorrentError,
self.core.remove_torrent,
'torrentidthatdoesntexist',
True,
)
@defer.inlineCallbacks
def test_remove_torrents(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = b64encode(_file.read())
torrent_id = yield self.core.add_torrent_file_async(
filename, filedump, options)
filename2 = common.get_test_data_file('unicode_filenames.torrent')
with open(filename2, 'rb') as _file:
filedump = b64encode(_file.read())
torrent_id2 = yield self.core.add_torrent_file_async(
filename2, filedump, options)
d = self.core.remove_torrents([torrent_id, torrent_id2], True)
def test_ret(val):
self.assertTrue(val == [])
d.addCallback(test_ret)
def test_session_state(val):
self.assertEqual(len(self.core.get_session_state()), 0)
d.addCallback(test_session_state)
yield d
@defer.inlineCallbacks
def test_remove_torrents_invalid(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = b64encode(_file.read())
torrent_id = yield self.core.add_torrent_file_async(
filename, filedump, options)
val = yield self.core.remove_torrents(
['invalidid1', 'invalidid2', torrent_id], False)
self.assertEqual(len(val), 2)
self.assertEqual(
val[0], ('invalidid1', 'torrent_id invalidid1 not in session.'))
self.assertEqual(
val[1], ('invalidid2', 'torrent_id invalidid2 not in session.'))
def test_get_session_status(self):
status = self.core.get_session_status(
['net.recv_tracker_bytes', 'net.sent_tracker_bytes'])
self.assertIsInstance(status, dict)
self.assertEqual(status['net.recv_tracker_bytes'], 0)
self.assertEqual(status['net.sent_tracker_bytes'], 0)
def test_get_session_status_all(self):
status = self.core.get_session_status([])
self.assertIsInstance(status, dict)
self.assertIn('upload_rate', status)
self.assertIn('net.recv_bytes', status)
def test_get_session_status_depr(self):
status = self.core.get_session_status(['num_peers', 'num_unchoked'])
self.assertIsInstance(status, dict)
self.assertEqual(status['num_peers'], 0)
self.assertEqual(status['num_unchoked'], 0)
def test_get_session_status_rates(self):
status = self.core.get_session_status(['upload_rate', 'download_rate'])
self.assertIsInstance(status, dict)
self.assertEqual(status['upload_rate'], 0)
def test_get_session_status_ratio(self):
status = self.core.get_session_status(
['write_hit_ratio', 'read_hit_ratio'])
self.assertIsInstance(status, dict)
self.assertEqual(status['write_hit_ratio'], 0.0)
self.assertEqual(status['read_hit_ratio'], 0.0)
def test_get_free_space(self):
space = self.core.get_free_space('.')
# get_free_space returns long on Python 2 (32-bit).
self.assertTrue(isinstance(space, integer_types))
self.assertTrue(space >= 0)
self.assertEqual(self.core.get_free_space('/someinvalidpath'), -1)
@pytest.mark.slow
def test_test_listen_port(self):
d = self.core.test_listen_port()
def result(r):
self.assertTrue(r in (True, False))
d.addCallback(result)
return d
def test_sanitize_filepath(self):
pathlist = {
'\\backslash\\path\\': 'backslash/path',
' single_file ': 'single_file',
'..': '',
'/../..../': '',
' Def ////ad./ / . . /b d /file': 'Def/ad./. ./b d/file',
'/ test /\\.. /.file/': 'test/.file',
'mytorrent/subfold/file1': 'mytorrent/subfold/file1',
'Torrent/folder/': 'Torrent/folder',
}
for key in pathlist:
self.assertEqual(
deluge.core.torrent.sanitize_filepath(key, folder=False),
pathlist[key])
self.assertEqual(
deluge.core.torrent.sanitize_filepath(key, folder=True),
pathlist[key] + '/',
)
def test_get_set_config_values(self):
self.assertEqual(self.core.get_config_values(['abc', 'foo']), {
'foo': None,
'abc': None
})
self.assertEqual(self.core.get_config_value('foobar'), None)
self.core.set_config({'abc': 'def', 'foo': 10, 'foobar': 'barfoo'})
self.assertEqual(self.core.get_config_values(['foo', 'abc']), {
'foo': 10,
'abc': 'def'
})
self.assertEqual(self.core.get_config_value('foobar'), 'barfoo')
def test_read_only_config_keys(self):
key = 'max_upload_speed'
self.core.read_only_config_keys = [key]
old_value = self.core.get_config_value(key)
self.core.set_config({key: old_value + 10})
new_value = self.core.get_config_value(key)
self.assertEqual(old_value, new_value)
self.core.read_only_config_keys = None
def test__create_peer_id(self):
self.assertEqual(self.core._create_peer_id('2.0.0'), '-DE200s-')
self.assertEqual(self.core._create_peer_id('2.0.0.dev15'), '-DE200D-')
self.assertEqual(self.core._create_peer_id('2.0.1rc1'), '-DE201r-')
self.assertEqual(self.core._create_peer_id('2.11.0b2'), '-DE2B0b-')
self.assertEqual(self.core._create_peer_id('2.4.12b2.dev3'),
'-DE24CD-')
class CoreTestCase(unittest.TestCase):
def setUp(self):
common.set_tmp_config_dir()
self.rpcserver = RPCServer(listen=False)
self.core = Core()
return component.start().addCallback(self.startWebserver)
def startWebserver(self, result):
self.website = Site(TopLevelResource())
self.webserver = reactor.listenTCP(51242, self.website)
return result
def tearDown(self):
def on_shutdown(result):
component._ComponentRegistry.components = {}
del self.rpcserver
del self.core
return self.webserver.stopListening()
return component.shutdown().addCallback(on_shutdown)
def test_add_torrent_file(self):
options = {}
filename = os.path.join(os.path.dirname(__file__), "test.torrent")
import base64
torrent_id = self.core.add_torrent_file(filename, base64.encodestring(open(filename).read()), options)
# Get the info hash from the test.torrent
from deluge.bencode import bdecode, bencode
info_hash = sha(bencode(bdecode(open(filename).read())["info"])).hexdigest()
self.assertEquals(torrent_id, info_hash)
def test_add_torrent_url(self):
url = "http://localhost:51242/ubuntu-9.04-desktop-i386.iso.torrent"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_torrent_url_with_cookie(self):
url = "http://localhost:51242/cookie"
options = {}
headers = { "Cookie" : "password=deluge" }
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallbacks(self.fail, self.assertIsInstance, errbackArgs=(Failure,))
d = self.core.add_torrent_url(url, options, headers)
d.addCallbacks(self.assertEquals, self.fail, callbackArgs=(info_hash,))
return d
def test_add_torrent_url_with_redirect(self):
url = "http://localhost:51242/redirect"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_torrent_url_with_partial_download(self):
url = "http://localhost:51242/partial"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_magnet(self):
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
import deluge.common
uri = deluge.common.create_magnet_uri(info_hash)
options = {}
torrent_id = self.core.add_torrent_magnet(uri, options)
self.assertEquals(torrent_id, info_hash)
def test_remove_torrent(self):
options = {}
filename = os.path.join(os.path.dirname(__file__), "test.torrent")
import base64
torrent_id = self.core.add_torrent_file(filename, base64.encodestring(open(filename).read()), options)
self.assertRaises(deluge.error.InvalidTorrentError, self.core.remove_torrent, "torrentidthatdoesntexist", True)
ret = self.core.remove_torrent(torrent_id, True)
self.assertTrue(ret)
self.assertEquals(len(self.core.get_session_state()), 0)
def test_get_session_status(self):
status = self.core.get_session_status(["upload_rate", "download_rate"])
self.assertEquals(type(status), dict)
self.assertEquals(status["upload_rate"], 0.0)
def test_get_cache_status(self):
status = self.core.get_cache_status()
self.assertEquals(type(status), dict)
self.assertEquals(status["write_hit_ratio"], 0.0)
self.assertEquals(status["read_hit_ratio"], 0.0)
def test_get_free_space(self):
space = self.core.get_free_space(".")
self.assertTrue(type(space) in (int, long))
self.assertTrue(space >= 0)
self.assertEquals(self.core.get_free_space("/someinvalidpath"), 0)
def test_test_listen_port(self):
d = self.core.test_listen_port()
def result(r):
self.assertTrue(r in (True, False))
d.addCallback(result)
return d
def test_sanitize_filepath(self):
pathlist = {
'\\backslash\\path\\' : 'backslash/path',
' single_file ': 'single_file',
'..' : '',
'/../..../': '',
' Def ////ad./ / . . /b d /file': 'Def/ad./. ./b d/file',
'/ test /\\.. /.file/': 'test/.file',
'mytorrent/subfold/file1': 'mytorrent/subfold/file1',
'Torrent/folder/': 'Torrent/folder',
}
for key in pathlist:
self.assertEquals(deluge.core.torrent.sanitize_filepath(key, folder=False), pathlist[key])
self.assertEquals(deluge.core.torrent.sanitize_filepath(key, folder=True), pathlist[key] + '/')
class TorrentmanagerTestCase(BaseTestCase):
def set_up(self):
self.config_dir = common.set_tmp_config_dir()
self.rpcserver = RPCServer(listen=False)
self.core = Core()
self.core.config.config['lsd'] = False
self.clock = task.Clock()
self.tm = self.core.torrentmanager
self.tm.callLater = self.clock.callLater
return component.start()
def tear_down(self):
def on_shutdown(result):
del self.rpcserver
del self.core
return component.shutdown().addCallback(on_shutdown)
@defer.inlineCallbacks
def test_remove_torrent(self):
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = _file.read()
torrent_id = yield self.core.add_torrent_file_async(
filename, b64encode(filedump), {})
self.assertTrue(self.tm.remove(torrent_id, False))
@defer.inlineCallbacks
def test_remove_magnet(self):
"""Test remove magnet before received metadata and delete_copies is True"""
magnet = 'magnet:?xt=urn:btih:ab570cdd5a17ea1b61e970bb72047de141bce173'
options = {}
self.core.config.config['copy_torrent_file'] = True
self.core.config.config['del_copy_torrent_file'] = True
torrent_id = yield self.core.add_torrent_magnet(magnet, options)
self.assertTrue(self.tm.remove(torrent_id, False))
def test_prefetch_metadata(self):
from deluge._libtorrent import lt
with open(common.get_test_data_file('test.torrent'), 'rb') as _file:
t_info = lt.torrent_info(lt.bdecode(_file.read()))
mock_alert = mock.MagicMock()
mock_alert.handle.info_hash = mock.MagicMock(
return_value='ab570cdd5a17ea1b61e970bb72047de141bce173')
mock_alert.handle.get_torrent_info = mock.MagicMock(
return_value=t_info)
magnet = 'magnet:?xt=urn:btih:ab570cdd5a17ea1b61e970bb72047de141bce173'
d = self.tm.prefetch_metadata(magnet, 30)
self.tm.on_alert_metadata_received(mock_alert)
expected = (
'ab570cdd5a17ea1b61e970bb72047de141bce173',
{
b'piece length':
32768,
b'sha1': (b'2\xce\xb6\xa8"\xd7\xf0\xd4\xbf\xdc^K\xba\x1bh'
b'\x9d\xc5\xb7\xac\xdd'),
b'name':
b'azcvsupdater_2.6.2.jar',
b'private':
0,
b'pieces': (b"\xdb\x04B\x05\xc3'\xdab\xb8su97\xa9u"
b'\xca<w\\\x1ef\xd4\x9b\x16\xa9}\xc0\x9f:\xfd'
b'\x97qv\x83\xa2"\xef\x9d7\x0by!\rl\xe5v\xb7'
b'\x18{\xf7/"P\xe9\x8d\x01D\x9e8\xbd\x16\xe3'
b'\xfb-\x9d\xaa\xbcM\x11\xba\x92\xfc\x13F\xf0'
b'\x1c\x86x+\xc8\xd0S\xa9\x90`\xa1\xe4\x82\xe8'
b'\xfc\x08\xf7\xe3\xe5\xf6\x85\x1c%\xe7%\n\xed'
b'\xc0\x1f\xa1;\x9a\xea\xcf\x90\x0c/F>\xdf\xdagA'
b'\xc42|\xda\x82\xf5\xa6b\xa1\xb8#\x80wI\xd8f'
b'\xf8\xbd\xacW\xab\xc3s\xe0\xbbw\xf2K\xbe\xee'
b'\xa8rG\xe1W\xe8\xb7\xc2i\xf3\xd8\xaf\x9d\xdc'
b'\xd0#\xf4\xc1\x12u\xcd\x0bE?:\xe8\x9c\x1cu'
b'\xabb(oj\r^\xd5\xd5A\x83\x88\x9a\xa1J\x1c?'
b'\xa1\xd6\x8c\x83\x9e&'),
b'length':
307949,
b'name.utf-8':
b'azcvsupdater_2.6.2.jar',
b'ed2k':
b'>p\xefl\xfa]\x95K\x1b^\xc2\\;;e\xb7',
},
)
self.assertEqual(expected, self.successResultOf(d))
def test_prefetch_metadata_timeout(self):
magnet = 'magnet:?xt=urn:btih:ab570cdd5a17ea1b61e970bb72047de141bce173'
d = self.tm.prefetch_metadata(magnet, 30)
self.clock.advance(30)
expected = ('ab570cdd5a17ea1b61e970bb72047de141bce173', None)
return d.addCallback(self.assertEqual, expected)
@pytest.mark.todo
def test_remove_torrent_false(self):
"""Test when remove_torrent returns False"""
common.todo_test(self)
def test_remove_invalid_torrent(self):
self.assertRaises(InvalidTorrentError, self.tm.remove,
'torrentidthatdoesntexist')
def test_open_state_from_python2(self):
"""Open a Python2 state with a UTF-8 encoded torrent filename."""
shutil.copy(
common.get_test_data_file('utf8_filename_torrents.state'),
os.path.join(self.config_dir, 'state', 'torrents.state'),
)
if windows_check():
raise unittest.SkipTest(
'Windows ModuleNotFoundError due to Linux line ending')
state = self.tm.open_state()
self.assertEqual(len(state.torrents), 1)
class CoreTestCase(unittest.TestCase):
def setUp(self):
common.set_tmp_config_dir()
self.rpcserver = RPCServer(listen=False)
self.core = Core()
d = component.start()
return d
def tearDown(self):
def on_shutdown(result):
component._ComponentRegistry.components = {}
del self.rpcserver
del self.core
return component.shutdown().addCallback(on_shutdown)
def test_add_torrent_file(self):
options = {}
filename = "../test.torrent"
import base64
torrent_id = self.core.add_torrent_file(
filename, base64.encodestring(open(filename).read()), options)
# Get the info hash from the test.torrent
from deluge.bencode import bdecode, bencode
info_hash = sha(bencode(bdecode(
open(filename).read())["info"])).hexdigest()
self.assertEquals(torrent_id, info_hash)
def test_add_torrent_url(self):
url = "http://deluge-torrent.org/ubuntu-9.04-desktop-i386.iso.torrent"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_torrent_url_with_cookie(self):
url = "http://deluge-torrent.org/test_torrent.php?test=cookie"
options = {}
headers = {"Cookie": "password=deluge"}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallbacks(self.fail,
self.assertIsInstance,
errbackArgs=(Failure, ))
d = self.core.add_torrent_url(url, options, headers)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_torrent_url_with_redirect(self):
url = "http://deluge-torrent.org/test_torrent.php?test=redirect"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_torrent_url_with_partial_download(self):
url = "http://deluge-torrent.org/test_torrent.php?test=partial"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_magnet(self):
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
import deluge.common
uri = deluge.common.create_magnet_uri(info_hash)
options = {}
torrent_id = self.core.add_torrent_magnet(uri, options)
self.assertEquals(torrent_id, info_hash)
def test_remove_torrent(self):
options = {}
filename = "../test.torrent"
import base64
torrent_id = self.core.add_torrent_file(
filename, base64.encodestring(open(filename).read()), options)
self.assertRaises(deluge.error.InvalidTorrentError,
self.core.remove_torrent, "torrentidthatdoesntexist",
True)
ret = self.core.remove_torrent(torrent_id, True)
self.assertTrue(ret)
self.assertEquals(len(self.core.get_session_state()), 0)
def test_get_session_status(self):
status = self.core.get_session_status(["upload_rate", "download_rate"])
self.assertEquals(type(status), dict)
self.assertEquals(status["upload_rate"], 0.0)
def test_get_cache_status(self):
status = self.core.get_cache_status()
self.assertEquals(type(status), dict)
self.assertEquals(status["write_hit_ratio"], 0.0)
self.assertEquals(status["read_hit_ratio"], 0.0)
def test_get_free_space(self):
space = self.core.get_free_space(".")
self.assertTrue(type(space) in (int, long))
self.assertTrue(space >= 0)
self.assertEquals(self.core.get_free_space("/someinvalidpath"), 0)
def test_test_listen_port(self):
d = self.core.test_listen_port()
def result(r):
self.assertTrue(r in (True, False))
d.addCallback(result)
return d
def test_sanitize_filepath(self):
pathlist = {
'\\backslash\\path\\': 'backslash/path',
' single_file ': 'single_file',
'..': '',
'/../..../': '',
' Def ////ad./ / . . /b d /file': 'Def/ad./. ./b d/file',
'/ test /\\.. /.file/': 'test/.file',
'mytorrent/subfold/file1': 'mytorrent/subfold/file1',
'Torrent/folder/': 'Torrent/folder',
}
for key in pathlist:
self.assertEquals(
deluge.core.torrent.sanitize_filepath(key, folder=False),
pathlist[key])
self.assertEquals(
deluge.core.torrent.sanitize_filepath(key, folder=True),
pathlist[key] + '/')
class CoreTestCase(BaseTestCase):
def set_up(self):
common.set_tmp_config_dir()
self.rpcserver = RPCServer(listen=False)
self.core = Core()
self.listen_port = 51242
return component.start().addCallback(self.start_web_server)
def start_web_server(self, result):
website = Site(TopLevelResource())
for dummy in range(10):
try:
self.webserver = reactor.listenTCP(self.listen_port, website)
except CannotListenError as ex:
error = ex
self.listen_port += 1
else:
break
else:
raise error
return result
def tear_down(self):
def on_shutdown(result):
del self.rpcserver
del self.core
return self.webserver.stopListening()
return component.shutdown().addCallback(on_shutdown)
@defer.inlineCallbacks
def test_add_torrent_files(self):
options = {}
filenames = ['test.torrent', 'test_torrent.file.torrent']
files_to_add = []
for f in filenames:
filename = common.get_test_data_file(f)
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
files_to_add.append((filename, filedump, options))
errors = yield self.core.add_torrent_files(files_to_add)
self.assertEqual(len(errors), 0)
@defer.inlineCallbacks
def test_add_torrent_files_error_duplicate(self):
options = {}
filenames = ['test.torrent', 'test.torrent']
files_to_add = []
for f in filenames:
filename = common.get_test_data_file(f)
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
files_to_add.append((filename, filedump, options))
errors = yield self.core.add_torrent_files(files_to_add)
self.assertEqual(len(errors), 1)
self.assertTrue(str(errors[0]).startswith('Torrent already in session'))
@defer.inlineCallbacks
def test_add_torrent_file(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id = yield self.core.add_torrent_file(filename, filedump, options)
# Get the info hash from the test.torrent
from deluge.bencode import bdecode, bencode
with open(filename, 'rb') as _file:
info_hash = sha(bencode(bdecode(_file.read())[b'info'])).hexdigest()
self.assertEquals(torrent_id, info_hash)
def test_add_torrent_file_invalid_filedump(self):
options = {}
filename = common.get_test_data_file('test.torrent')
self.assertRaises(AddTorrentError, self.core.add_torrent_file, filename, False, options)
@defer.inlineCallbacks
def test_add_torrent_url(self):
url = 'http://localhost:%d/ubuntu-9.04-desktop-i386.iso.torrent' % self.listen_port
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
torrent_id = yield self.core.add_torrent_url(url, options)
self.assertEqual(torrent_id, info_hash)
def test_add_torrent_url_with_cookie(self):
url = 'http://localhost:%d/cookie' % self.listen_port
options = {}
headers = {'Cookie': 'password=deluge'}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallbacks(self.fail, self.assertIsInstance, errbackArgs=(Failure,))
d = self.core.add_torrent_url(url, options, headers)
d.addCallbacks(self.assertEqual, self.fail, callbackArgs=(info_hash,))
return d
def test_add_torrent_url_with_redirect(self):
url = 'http://localhost:%d/redirect' % self.listen_port
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEqual, info_hash)
return d
def test_add_torrent_url_with_partial_download(self):
url = 'http://localhost:%d/partial' % self.listen_port
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEqual, info_hash)
return d
@defer.inlineCallbacks
def test_add_torrent_magnet(self):
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
uri = deluge.common.create_magnet_uri(info_hash)
options = {}
torrent_id = yield self.core.add_torrent_magnet(uri, options)
self.assertEqual(torrent_id, info_hash)
@defer.inlineCallbacks
def test_remove_torrent(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id = yield self.core.add_torrent_file(filename, filedump, options)
removed = self.core.remove_torrent(torrent_id, True)
self.assertTrue(removed)
self.assertEqual(len(self.core.get_session_state()), 0)
def test_remove_torrent_invalid(self):
self.assertRaises(InvalidTorrentError, self.core.remove_torrent, 'torrentidthatdoesntexist', True)
@defer.inlineCallbacks
def test_remove_torrents(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id = yield self.core.add_torrent_file(filename, filedump, options)
filename2 = common.get_test_data_file('unicode_filenames.torrent')
with open(filename2, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id2 = yield self.core.add_torrent_file(filename2, filedump, options)
d = self.core.remove_torrents([torrent_id, torrent_id2], True)
def test_ret(val):
self.assertTrue(val == [])
d.addCallback(test_ret)
def test_session_state(val):
self.assertEqual(len(self.core.get_session_state()), 0)
d.addCallback(test_session_state)
yield d
@defer.inlineCallbacks
def test_remove_torrents_invalid(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id = yield self.core.add_torrent_file(filename, filedump, options)
val = yield self.core.remove_torrents(['invalidid1', 'invalidid2', torrent_id], False)
self.assertEqual(len(val), 2)
self.assertEqual(val[0], ('invalidid1', 'torrent_id invalidid1 not in session.'))
self.assertEqual(val[1], ('invalidid2', 'torrent_id invalidid2 not in session.'))
def test_get_session_status(self):
status = self.core.get_session_status(['upload_rate', 'download_rate'])
self.assertEqual(type(status), dict)
self.assertEqual(status['upload_rate'], 0.0)
def test_get_session_status_ratio(self):
status = self.core.get_session_status(['write_hit_ratio', 'read_hit_ratio'])
self.assertEqual(type(status), dict)
self.assertEqual(status['write_hit_ratio'], 0.0)
self.assertEqual(status['read_hit_ratio'], 0.0)
def test_get_free_space(self):
space = self.core.get_free_space('.')
# get_free_space returns long on Python 2 (32-bit).
self.assertTrue(isinstance(space, int if not PY2 else (int, long)))
self.assertTrue(space >= 0)
self.assertEqual(self.core.get_free_space('/someinvalidpath'), -1)
@pytest.mark.slow
def test_test_listen_port(self):
d = self.core.test_listen_port()
def result(r):
self.assertTrue(r in (True, False))
d.addCallback(result)
return d
def test_sanitize_filepath(self):
pathlist = {
'\\backslash\\path\\': 'backslash/path',
' single_file ': 'single_file',
'..': '',
'/../..../': '',
' Def ////ad./ / . . /b d /file': 'Def/ad./. ./b d/file',
'/ test /\\.. /.file/': 'test/.file',
'mytorrent/subfold/file1': 'mytorrent/subfold/file1',
'Torrent/folder/': 'Torrent/folder',
}
for key in pathlist:
self.assertEqual(deluge.core.torrent.sanitize_filepath(key, folder=False), pathlist[key])
self.assertEqual(deluge.core.torrent.sanitize_filepath(key, folder=True), pathlist[key] + '/')
def test_get_set_config_values(self):
self.assertEqual(self.core.get_config_values(['abc', 'foo']), {'foo': None, 'abc': None})
self.assertEqual(self.core.get_config_value('foobar'), None)
self.core.set_config({'abc': 'def', 'foo': 10, 'foobar': 'barfoo'})
self.assertEqual(self.core.get_config_values(['foo', 'abc']), {'foo': 10, 'abc': 'def'})
self.assertEqual(self.core.get_config_value('foobar'), 'barfoo')
def test_read_only_config_keys(self):
key = 'max_upload_speed'
self.core.read_only_config_keys = [key]
old_value = self.core.get_config_value(key)
self.core.set_config({key: old_value + 10})
new_value = self.core.get_config_value(key)
self.assertEqual(old_value, new_value)
self.core.read_only_config_keys = None
class CoreTestCase(unittest.TestCase):
def setUp(self):
common.set_tmp_config_dir()
self.rpcserver = RPCServer(listen=False)
self.core = Core()
return component.start().addCallback(self.startWebserver)
def startWebserver(self, result):
self.website = Site(TopLevelResource())
self.webserver = reactor.listenTCP(51242, self.website)
return result
def tearDown(self):
def on_shutdown(result):
component._ComponentRegistry.components = {}
del self.rpcserver
del self.core
return self.webserver.stopListening()
return component.shutdown().addCallback(on_shutdown)
def test_add_torrent_file(self):
options = {}
filename = os.path.join(os.path.dirname(__file__), "test.torrent")
import base64
torrent_id = self.core.add_torrent_file(
filename, base64.encodestring(open(filename).read()), options)
# Get the info hash from the test.torrent
from deluge.bencode import bdecode, bencode
info_hash = sha(bencode(bdecode(
open(filename).read())["info"])).hexdigest()
self.assertEquals(torrent_id, info_hash)
def test_add_torrent_url(self):
url = "http://localhost:51242/ubuntu-9.04-desktop-i386.iso.torrent"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_torrent_url_with_cookie(self):
url = "http://localhost:51242/cookie"
options = {}
headers = {"Cookie": "password=deluge"}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallbacks(self.fail,
self.assertIsInstance,
errbackArgs=(Failure, ))
d = self.core.add_torrent_url(url, options, headers)
d.addCallbacks(self.assertEquals,
self.fail,
callbackArgs=(info_hash, ))
return d
def test_add_torrent_url_with_redirect(self):
url = "http://localhost:51242/redirect"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_torrent_url_with_partial_download(self):
url = "http://localhost:51242/partial"
options = {}
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash)
return d
def test_add_magnet(self):
info_hash = "60d5d82328b4547511fdeac9bf4d0112daa0ce00"
import deluge.common
uri = deluge.common.create_magnet_uri(info_hash)
options = {}
torrent_id = self.core.add_torrent_magnet(uri, options)
self.assertEquals(torrent_id, info_hash)
def test_remove_torrent(self):
options = {}
filename = os.path.join(os.path.dirname(__file__), "test.torrent")
import base64
torrent_id = self.core.add_torrent_file(
filename, base64.encodestring(open(filename).read()), options)
self.assertRaises(deluge.error.InvalidTorrentError,
self.core.remove_torrent, "torrentidthatdoesntexist",
True)
ret = self.core.remove_torrent(torrent_id, True)
self.assertTrue(ret)
self.assertEquals(len(self.core.get_session_state()), 0)
def test_get_session_status(self):
status = self.core.get_session_status(["upload_rate", "download_rate"])
self.assertEquals(type(status), dict)
self.assertEquals(status["upload_rate"], 0.0)
def test_get_cache_status(self):
status = self.core.get_cache_status()
self.assertEquals(type(status), dict)
self.assertEquals(status["write_hit_ratio"], 0.0)
self.assertEquals(status["read_hit_ratio"], 0.0)
def test_get_free_space(self):
space = self.core.get_free_space(".")
self.assertTrue(type(space) in (int, long))
self.assertTrue(space >= 0)
self.assertEquals(self.core.get_free_space("/someinvalidpath"), 0)
def test_test_listen_port(self):
d = self.core.test_listen_port()
def result(r):
self.assertTrue(r in (True, False))
d.addCallback(result)
return d
class CoreTestCase(BaseTestCase):
def set_up(self):
common.set_tmp_config_dir()
self.rpcserver = RPCServer(listen=False)
self.core = Core()
self.listen_port = 51242
return component.start().addCallback(self.start_web_server)
def start_web_server(self, result):
website = Site(TopLevelResource())
for dummy in range(10):
try:
self.webserver = reactor.listenTCP(self.listen_port, website)
except CannotListenError as ex:
error = ex
self.listen_port += 1
else:
break
else:
raise error
return result
def tear_down(self):
def on_shutdown(result):
del self.rpcserver
del self.core
return self.webserver.stopListening()
return component.shutdown().addCallback(on_shutdown)
@defer.inlineCallbacks
def test_add_torrent_files(self):
options = {}
filenames = ['test.torrent', 'test_torrent.file.torrent']
files_to_add = []
for f in filenames:
filename = common.get_test_data_file(f)
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
files_to_add.append((filename, filedump, options))
errors = yield self.core.add_torrent_files(files_to_add)
self.assertEqual(len(errors), 0)
@defer.inlineCallbacks
def test_add_torrent_files_error_duplicate(self):
options = {}
filenames = ['test.torrent', 'test.torrent']
files_to_add = []
for f in filenames:
filename = common.get_test_data_file(f)
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
files_to_add.append((filename, filedump, options))
errors = yield self.core.add_torrent_files(files_to_add)
self.assertEqual(len(errors), 1)
self.assertTrue(
str(errors[0]).startswith('Torrent already in session'))
@defer.inlineCallbacks
def test_add_torrent_file(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id = yield self.core.add_torrent_file(filename, filedump,
options)
# Get the info hash from the test.torrent
from deluge.bencode import bdecode, bencode
with open(filename, 'rb') as _file:
info_hash = sha(bencode(bdecode(
_file.read())[b'info'])).hexdigest()
self.assertEquals(torrent_id, info_hash)
def test_add_torrent_file_invalid_filedump(self):
options = {}
filename = common.get_test_data_file('test.torrent')
self.assertRaises(AddTorrentError, self.core.add_torrent_file,
filename, False, options)
@defer.inlineCallbacks
def test_add_torrent_url(self):
url = 'http://localhost:%d/ubuntu-9.04-desktop-i386.iso.torrent' % self.listen_port
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
torrent_id = yield self.core.add_torrent_url(url, options)
self.assertEqual(torrent_id, info_hash)
def test_add_torrent_url_with_cookie(self):
url = 'http://localhost:%d/cookie' % self.listen_port
options = {}
headers = {'Cookie': 'password=deluge'}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallbacks(self.fail,
self.assertIsInstance,
errbackArgs=(Failure, ))
d = self.core.add_torrent_url(url, options, headers)
d.addCallbacks(self.assertEqual, self.fail, callbackArgs=(info_hash, ))
return d
def test_add_torrent_url_with_redirect(self):
url = 'http://localhost:%d/redirect' % self.listen_port
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEqual, info_hash)
return d
def test_add_torrent_url_with_partial_download(self):
url = 'http://localhost:%d/partial' % self.listen_port
options = {}
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEqual, info_hash)
return d
@defer.inlineCallbacks
def test_add_torrent_magnet(self):
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
uri = deluge.common.create_magnet_uri(info_hash)
options = {}
torrent_id = yield self.core.add_torrent_magnet(uri, options)
self.assertEqual(torrent_id, info_hash)
@defer.inlineCallbacks
def test_remove_torrent(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id = yield self.core.add_torrent_file(filename, filedump,
options)
removed = self.core.remove_torrent(torrent_id, True)
self.assertTrue(removed)
self.assertEqual(len(self.core.get_session_state()), 0)
def test_remove_torrent_invalid(self):
self.assertRaises(InvalidTorrentError, self.core.remove_torrent,
'torrentidthatdoesntexist', True)
@defer.inlineCallbacks
def test_remove_torrents(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id = yield self.core.add_torrent_file(filename, filedump,
options)
filename2 = common.get_test_data_file('unicode_filenames.torrent')
with open(filename2, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id2 = yield self.core.add_torrent_file(filename2, filedump,
options)
d = self.core.remove_torrents([torrent_id, torrent_id2], True)
def test_ret(val):
self.assertTrue(val == [])
d.addCallback(test_ret)
def test_session_state(val):
self.assertEqual(len(self.core.get_session_state()), 0)
d.addCallback(test_session_state)
yield d
@defer.inlineCallbacks
def test_remove_torrents_invalid(self):
options = {}
filename = common.get_test_data_file('test.torrent')
with open(filename, 'rb') as _file:
filedump = base64.encodestring(_file.read())
torrent_id = yield self.core.add_torrent_file(
filename, filedump, options)
val = yield self.core.remove_torrents(
['invalidid1', 'invalidid2', torrent_id], False)
self.assertEqual(len(val), 2)
self.assertEqual(
val[0], ('invalidid1', 'torrent_id invalidid1 not in session.'))
self.assertEqual(
val[1], ('invalidid2', 'torrent_id invalidid2 not in session.'))
def test_get_session_status(self):
status = self.core.get_session_status(['upload_rate', 'download_rate'])
self.assertEqual(type(status), dict)
self.assertEqual(status['upload_rate'], 0.0)
def test_get_session_status_ratio(self):
status = self.core.get_session_status(
['write_hit_ratio', 'read_hit_ratio'])
self.assertEqual(type(status), dict)
self.assertEqual(status['write_hit_ratio'], 0.0)
self.assertEqual(status['read_hit_ratio'], 0.0)
def test_get_free_space(self):
space = self.core.get_free_space('.')
# get_free_space returns long on Python 2 (32-bit).
self.assertTrue(isinstance(space, int if not PY2 else (int, long)))
self.assertTrue(space >= 0)
self.assertEqual(self.core.get_free_space('/someinvalidpath'), -1)
@pytest.mark.slow
def test_test_listen_port(self):
d = self.core.test_listen_port()
def result(r):
self.assertTrue(r in (True, False))
d.addCallback(result)
return d
def test_sanitize_filepath(self):
pathlist = {
'\\backslash\\path\\': 'backslash/path',
' single_file ': 'single_file',
'..': '',
'/../..../': '',
' Def ////ad./ / . . /b d /file': 'Def/ad./. ./b d/file',
'/ test /\\.. /.file/': 'test/.file',
'mytorrent/subfold/file1': 'mytorrent/subfold/file1',
'Torrent/folder/': 'Torrent/folder',
}
for key in pathlist:
self.assertEqual(
deluge.core.torrent.sanitize_filepath(key, folder=False),
pathlist[key])
self.assertEqual(
deluge.core.torrent.sanitize_filepath(key, folder=True),
pathlist[key] + '/')
def test_get_set_config_values(self):
self.assertEqual(self.core.get_config_values(['abc', 'foo']), {
'foo': None,
'abc': None
})
self.assertEqual(self.core.get_config_value('foobar'), None)
self.core.set_config({'abc': 'def', 'foo': 10, 'foobar': 'barfoo'})
self.assertEqual(self.core.get_config_values(['foo', 'abc']), {
'foo': 10,
'abc': 'def'
})
self.assertEqual(self.core.get_config_value('foobar'), 'barfoo')
def test_read_only_config_keys(self):
key = 'max_upload_speed'
self.core.read_only_config_keys = [key]
old_value = self.core.get_config_value(key)
self.core.set_config({key: old_value + 10})
new_value = self.core.get_config_value(key)
self.assertEqual(old_value, new_value)
self.core.read_only_config_keys = None
