mirror of
https://github.com/codex-storage/deluge.git
synced 2025-02-03 07:03:39 +00:00
[#2966] [Tests] Rename deprecated method aliases
This commit is contained in:
Calum Lind
parent
d09df063a5
commit
73ea123f1a
@ -28,7 +28,7 @@ class AlertManagerTestCase(BaseTestCase):
|
||||
return
|
||||
|
||||
self.am.register_handler('dummy_alert', handler)
|
||||
self.assertEquals(self.am.handlers['dummy_alert'], [handler])
|
||||
self.assertEqual(self.am.handlers['dummy_alert'], [handler])
|
||||
|
||||
def test_deregister_handler(self):
|
||||
def handler(alert):
|
||||
@ -36,4 +36,4 @@ class AlertManagerTestCase(BaseTestCase):
|
||||
|
||||
self.am.register_handler('dummy_alert', handler)
|
||||
self.am.deregister_handler(handler)
|
||||
self.assertEquals(self.am.handlers['dummy_alert'], [])
|
||||
self.assertEqual(self.am.handlers['dummy_alert'], [])
|
||||
|
||||
@ -24,7 +24,7 @@ class AuthManagerTestCase(BaseTestCase):
|
||||
|
||||
def test_authorize(self):
|
||||
from deluge.ui import common
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
self.auth.authorize(*common.get_localhost_auth()),
|
||||
AUTH_LEVEL_ADMIN
|
||||
)
|
||||
|
||||
@ -118,7 +118,7 @@ class ClientTestCase(BaseTestCase, DaemonBase):
|
||||
failure.trap(error.BadLoginError),
|
||||
error.BadLoginError
|
||||
)
|
||||
self.assertEquals(failure.value.message, 'Password does not match')
|
||||
self.assertEqual(failure.value.message, 'Password does not match')
|
||||
self.addCleanup(client.disconnect)
|
||||
|
||||
d.addCallbacks(self.fail, on_failure)
|
||||
@ -133,7 +133,7 @@ class ClientTestCase(BaseTestCase, DaemonBase):
|
||||
failure.trap(error.BadLoginError),
|
||||
error.BadLoginError
|
||||
)
|
||||
self.assertEquals(failure.value.message, 'Username does not exist')
|
||||
self.assertEqual(failure.value.message, 'Username does not exist')
|
||||
self.addCleanup(client.disconnect)
|
||||
|
||||
d.addCallbacks(self.fail, on_failure)
|
||||
@ -161,7 +161,7 @@ class ClientTestCase(BaseTestCase, DaemonBase):
|
||||
yield client.core.create_account('testuser', 'testpw', 'DEFAULT')
|
||||
yield client.disconnect()
|
||||
ret = yield client.connect('localhost', self.listen_port, username='testuser', password='testpw')
|
||||
self.assertEquals(ret, deluge.common.AUTH_LEVEL_NORMAL)
|
||||
self.assertEqual(ret, deluge.common.AUTH_LEVEL_NORMAL)
|
||||
yield
|
||||
|
||||
@defer.inlineCallbacks
|
||||
|
||||
@ -24,91 +24,91 @@ class CommonTestCase(unittest.TestCase):
|
||||
pass
|
||||
|
||||
def test_fsize(self):
|
||||
self.assertEquals(fsize(0), '0 B')
|
||||
self.assertEquals(fsize(100), '100 B')
|
||||
self.assertEquals(fsize(1023), '1023 B')
|
||||
self.assertEquals(fsize(1024), '1.0 KiB')
|
||||
self.assertEquals(fsize(1048575), '1024.0 KiB')
|
||||
self.assertEquals(fsize(1048576), '1.0 MiB')
|
||||
self.assertEquals(fsize(1073741823), '1024.0 MiB')
|
||||
self.assertEquals(fsize(1073741824), '1.0 GiB')
|
||||
self.assertEquals(fsize(112245), '109.6 KiB')
|
||||
self.assertEquals(fsize(110723441824), '103.1 GiB')
|
||||
self.assertEquals(fsize(1099511627775), '1024.0 GiB')
|
||||
self.assertEquals(fsize(1099511627777), '1.0 TiB')
|
||||
self.assertEquals(fsize(766148267453245), '696.8 TiB')
|
||||
self.assertEqual(fsize(0), '0 B')
|
||||
self.assertEqual(fsize(100), '100 B')
|
||||
self.assertEqual(fsize(1023), '1023 B')
|
||||
self.assertEqual(fsize(1024), '1.0 KiB')
|
||||
self.assertEqual(fsize(1048575), '1024.0 KiB')
|
||||
self.assertEqual(fsize(1048576), '1.0 MiB')
|
||||
self.assertEqual(fsize(1073741823), '1024.0 MiB')
|
||||
self.assertEqual(fsize(1073741824), '1.0 GiB')
|
||||
self.assertEqual(fsize(112245), '109.6 KiB')
|
||||
self.assertEqual(fsize(110723441824), '103.1 GiB')
|
||||
self.assertEqual(fsize(1099511627775), '1024.0 GiB')
|
||||
self.assertEqual(fsize(1099511627777), '1.0 TiB')
|
||||
self.assertEqual(fsize(766148267453245), '696.8 TiB')
|
||||
|
||||
def test_fpcnt(self):
|
||||
self.failUnless(fpcnt(0.9311) == '93.11%')
|
||||
self.assertTrue(fpcnt(0.9311) == '93.11%')
|
||||
|
||||
def test_fspeed(self):
|
||||
self.failUnless(fspeed(43134) == '42.1 KiB/s')
|
||||
self.assertTrue(fspeed(43134) == '42.1 KiB/s')
|
||||
|
||||
def test_fpeer(self):
|
||||
self.failUnless(fpeer(10, 20) == '10 (20)')
|
||||
self.failUnless(fpeer(10, -1) == '10')
|
||||
self.assertTrue(fpeer(10, 20) == '10 (20)')
|
||||
self.assertTrue(fpeer(10, -1) == '10')
|
||||
|
||||
def test_ftime(self):
|
||||
self.failUnless(ftime(0) == '')
|
||||
self.failUnless(ftime(5) == '5s')
|
||||
self.failUnless(ftime(100) == '1m 40s')
|
||||
self.failUnless(ftime(3789) == '1h 3m')
|
||||
self.failUnless(ftime(23011) == '6h 23m')
|
||||
self.failUnless(ftime(391187) == '4d 12h')
|
||||
self.failUnless(ftime(604800) == '1w 0d')
|
||||
self.failUnless(ftime(13893086) == '22w 6d')
|
||||
self.failUnless(ftime(59740269) == '1y 46w')
|
||||
self.assertTrue(ftime(0) == '')
|
||||
self.assertTrue(ftime(5) == '5s')
|
||||
self.assertTrue(ftime(100) == '1m 40s')
|
||||
self.assertTrue(ftime(3789) == '1h 3m')
|
||||
self.assertTrue(ftime(23011) == '6h 23m')
|
||||
self.assertTrue(ftime(391187) == '4d 12h')
|
||||
self.assertTrue(ftime(604800) == '1w 0d')
|
||||
self.assertTrue(ftime(13893086) == '22w 6d')
|
||||
self.assertTrue(ftime(59740269) == '1y 46w')
|
||||
|
||||
def test_fdate(self):
|
||||
self.failUnless(fdate(-1) == '')
|
||||
self.assertTrue(fdate(-1) == '')
|
||||
|
||||
def test_is_url(self):
|
||||
self.failUnless(is_url('http://deluge-torrent.org'))
|
||||
self.failIf(is_url('file://test.torrent'))
|
||||
self.assertTrue(is_url('http://deluge-torrent.org'))
|
||||
self.assertFalse(is_url('file://test.torrent'))
|
||||
|
||||
def test_is_magnet(self):
|
||||
self.failUnless(is_magnet('magnet:?xt=urn:btih:SU5225URMTUEQLDXQWRB2EQWN6KLTYKN'))
|
||||
self.assertTrue(is_magnet('magnet:?xt=urn:btih:SU5225URMTUEQLDXQWRB2EQWN6KLTYKN'))
|
||||
|
||||
def test_is_infohash(self):
|
||||
self.failUnless(is_infohash('2dc5d0e71a66fe69649a640d39cb00a259704973'))
|
||||
self.assertTrue(is_infohash('2dc5d0e71a66fe69649a640d39cb00a259704973'))
|
||||
|
||||
def test_get_path_size(self):
|
||||
self.failUnless(get_path_size(os.devnull) == 0)
|
||||
self.failUnless(get_path_size('non-existant.file') == -1)
|
||||
self.assertTrue(get_path_size(os.devnull) == 0)
|
||||
self.assertTrue(get_path_size('non-existant.file') == -1)
|
||||
|
||||
def test_is_ip(self):
|
||||
self.failUnless(is_ip('192.0.2.0'))
|
||||
self.failIf(is_ip('192..0.0'))
|
||||
self.failUnless(is_ip('2001:db8::'))
|
||||
self.failIf(is_ip('2001:db8:'))
|
||||
self.assertTrue(is_ip('192.0.2.0'))
|
||||
self.assertFalse(is_ip('192..0.0'))
|
||||
self.assertTrue(is_ip('2001:db8::'))
|
||||
self.assertFalse(is_ip('2001:db8:'))
|
||||
|
||||
def test_is_ipv4(self):
|
||||
self.failUnless(is_ipv4('192.0.2.0'))
|
||||
self.failIf(is_ipv4('192..0.0'))
|
||||
self.assertTrue(is_ipv4('192.0.2.0'))
|
||||
self.assertFalse(is_ipv4('192..0.0'))
|
||||
|
||||
def test_is_ipv6(self):
|
||||
self.failUnless(is_ipv6('2001:db8::'))
|
||||
self.failIf(is_ipv6('2001:db8:'))
|
||||
self.assertTrue(is_ipv6('2001:db8::'))
|
||||
self.assertFalse(is_ipv6('2001:db8:'))
|
||||
|
||||
def test_version_split(self):
|
||||
self.failUnless(VersionSplit('1.2.2') == VersionSplit('1.2.2'))
|
||||
self.failUnless(VersionSplit('1.2.1') < VersionSplit('1.2.2'))
|
||||
self.failUnless(VersionSplit('1.1.9') < VersionSplit('1.2.2'))
|
||||
self.failUnless(VersionSplit('1.2.2') > VersionSplit('1.2.1'))
|
||||
self.failUnless(VersionSplit('1.2.2') < VersionSplit('1.2.2-dev'))
|
||||
self.failUnless(VersionSplit('1.2.2-dev') < VersionSplit('1.3.0-rc2'))
|
||||
self.failUnless(VersionSplit('1.2.2') > VersionSplit('1.2.2-rc2'))
|
||||
self.failUnless(VersionSplit('1.2.2-rc2-dev') > VersionSplit('1.2.2-rc2'))
|
||||
self.failUnless(VersionSplit('1.2.2-rc3') > VersionSplit('1.2.2-rc2'))
|
||||
self.failUnless(VersionSplit('0.14.9') == VersionSplit('0.14.9'))
|
||||
self.failUnless(VersionSplit('0.14.9') > VersionSplit('0.14.5'))
|
||||
self.failUnless(VersionSplit('0.14.10') >= VersionSplit('0.14.9'))
|
||||
self.failUnless(VersionSplit('1.4.0') > VersionSplit('1.3.900.dev123'))
|
||||
self.failUnless(VersionSplit('1.3.2rc2.dev1') < VersionSplit('1.3.2-rc2'))
|
||||
self.failUnless(VersionSplit('1.3.900.dev888') > VersionSplit('1.3.900.dev123'))
|
||||
self.failUnless(VersionSplit('1.4.0') > VersionSplit('1.4.0.dev123'))
|
||||
self.failUnless(VersionSplit('1.4.0.dev1') < VersionSplit('1.4.0'))
|
||||
self.failUnless(VersionSplit('1.4.0a1') < VersionSplit('1.4.0'))
|
||||
self.assertTrue(VersionSplit('1.2.2') == VersionSplit('1.2.2'))
|
||||
self.assertTrue(VersionSplit('1.2.1') < VersionSplit('1.2.2'))
|
||||
self.assertTrue(VersionSplit('1.1.9') < VersionSplit('1.2.2'))
|
||||
self.assertTrue(VersionSplit('1.2.2') > VersionSplit('1.2.1'))
|
||||
self.assertTrue(VersionSplit('1.2.2') < VersionSplit('1.2.2-dev'))
|
||||
self.assertTrue(VersionSplit('1.2.2-dev') < VersionSplit('1.3.0-rc2'))
|
||||
self.assertTrue(VersionSplit('1.2.2') > VersionSplit('1.2.2-rc2'))
|
||||
self.assertTrue(VersionSplit('1.2.2-rc2-dev') > VersionSplit('1.2.2-rc2'))
|
||||
self.assertTrue(VersionSplit('1.2.2-rc3') > VersionSplit('1.2.2-rc2'))
|
||||
self.assertTrue(VersionSplit('0.14.9') == VersionSplit('0.14.9'))
|
||||
self.assertTrue(VersionSplit('0.14.9') > VersionSplit('0.14.5'))
|
||||
self.assertTrue(VersionSplit('0.14.10') >= VersionSplit('0.14.9'))
|
||||
self.assertTrue(VersionSplit('1.4.0') > VersionSplit('1.3.900.dev123'))
|
||||
self.assertTrue(VersionSplit('1.3.2rc2.dev1') < VersionSplit('1.3.2-rc2'))
|
||||
self.assertTrue(VersionSplit('1.3.900.dev888') > VersionSplit('1.3.900.dev123'))
|
||||
self.assertTrue(VersionSplit('1.4.0') > VersionSplit('1.4.0.dev123'))
|
||||
self.assertTrue(VersionSplit('1.4.0.dev1') < VersionSplit('1.4.0'))
|
||||
self.assertTrue(VersionSplit('1.4.0a1') < VersionSplit('1.4.0'))
|
||||
|
||||
def test_parse_human_size(self):
|
||||
from deluge.common import parse_human_size
|
||||
@ -126,4 +126,4 @@ class CommonTestCase(unittest.TestCase):
|
||||
|
||||
for human_size, byte_size in sizes:
|
||||
parsed = parse_human_size(human_size)
|
||||
self.assertEquals(parsed, byte_size, 'Mismatch when converting: %s' % human_size)
|
||||
self.assertEqual(parsed, byte_size, 'Mismatch when converting: %s' % human_size)
|
||||
|
||||
@ -78,8 +78,8 @@ class ComponentTestClass(BaseTestCase):
|
||||
|
||||
def test_start_component(self):
|
||||
def on_start(result, c):
|
||||
self.assertEquals(c._component_state, 'Started')
|
||||
self.assertEquals(c.start_count, 1)
|
||||
self.assertEqual(c._component_state, 'Started')
|
||||
self.assertEqual(c.start_count, 1)
|
||||
|
||||
c = ComponentTester('test_start_c1')
|
||||
d = component.start(['test_start_c1'])
|
||||
@ -88,16 +88,16 @@ class ComponentTestClass(BaseTestCase):
|
||||
|
||||
def test_start_stop_depends(self):
|
||||
def on_stop(result, c1, c2):
|
||||
self.assertEquals(c1._component_state, 'Stopped')
|
||||
self.assertEquals(c2._component_state, 'Stopped')
|
||||
self.assertEquals(c1.stop_count, 1)
|
||||
self.assertEquals(c2.stop_count, 1)
|
||||
self.assertEqual(c1._component_state, 'Stopped')
|
||||
self.assertEqual(c2._component_state, 'Stopped')
|
||||
self.assertEqual(c1.stop_count, 1)
|
||||
self.assertEqual(c2.stop_count, 1)
|
||||
|
||||
def on_start(result, c1, c2):
|
||||
self.assertEquals(c1._component_state, 'Started')
|
||||
self.assertEquals(c2._component_state, 'Started')
|
||||
self.assertEquals(c1.start_count, 1)
|
||||
self.assertEquals(c2.start_count, 1)
|
||||
self.assertEqual(c1._component_state, 'Started')
|
||||
self.assertEqual(c2._component_state, 'Started')
|
||||
self.assertEqual(c1.start_count, 1)
|
||||
self.assertEqual(c2.start_count, 1)
|
||||
return component.stop(['test_start_depends_c1']).addCallback(on_stop, c1, c2)
|
||||
|
||||
c1 = ComponentTester('test_start_depends_c1')
|
||||
@ -124,8 +124,8 @@ class ComponentTestClass(BaseTestCase):
|
||||
def test_start_all(self):
|
||||
def on_start(*args):
|
||||
for c in args[1:]:
|
||||
self.assertEquals(c._component_state, 'Started')
|
||||
self.assertEquals(c.start_count, 1)
|
||||
self.assertEqual(c._component_state, 'Started')
|
||||
self.assertEqual(c.start_count, 1)
|
||||
|
||||
ret = self.start_with_depends()
|
||||
ret[0].addCallback(on_start, *ret[1:])
|
||||
@ -141,12 +141,12 @@ class ComponentTestClass(BaseTestCase):
|
||||
|
||||
def test_stop_component(self):
|
||||
def on_stop(result, c):
|
||||
self.assertEquals(c._component_state, 'Stopped')
|
||||
self.assertEqual(c._component_state, 'Stopped')
|
||||
self.assertFalse(c._component_timer.running)
|
||||
self.assertEquals(c.stop_count, 1)
|
||||
self.assertEqual(c.stop_count, 1)
|
||||
|
||||
def on_start(result, c):
|
||||
self.assertEquals(c._component_state, 'Started')
|
||||
self.assertEqual(c._component_state, 'Started')
|
||||
return component.stop(['test_stop_component_c1']).addCallback(on_stop, c)
|
||||
|
||||
c = ComponentTesterUpdate('test_stop_component_c1')
|
||||
@ -157,12 +157,12 @@ class ComponentTestClass(BaseTestCase):
|
||||
def test_stop_all(self):
|
||||
def on_stop(result, *args):
|
||||
for c in args:
|
||||
self.assertEquals(c._component_state, 'Stopped')
|
||||
self.assertEquals(c.stop_count, 1)
|
||||
self.assertEqual(c._component_state, 'Stopped')
|
||||
self.assertEqual(c.stop_count, 1)
|
||||
|
||||
def on_start(result, *args):
|
||||
for c in args:
|
||||
self.assertEquals(c._component_state, 'Started')
|
||||
self.assertEqual(c._component_state, 'Started')
|
||||
return component.stop().addCallback(on_stop, *args)
|
||||
|
||||
ret = self.start_with_depends()
|
||||
@ -228,17 +228,19 @@ class ComponentTestClass(BaseTestCase):
|
||||
self._observer._ignoreErrors(component.ComponentException)
|
||||
|
||||
result = yield component.start()
|
||||
self.failUnlessEqual([(result[0][0], result[0][1].value)],
|
||||
[(defer.FAILURE,
|
||||
component.ComponentException('Trying to start component "%s" but it is '
|
||||
'not in a stopped state. Current state: %s' %
|
||||
('test_pause_c1', 'Paused'), ''))])
|
||||
self.assertEqual(
|
||||
[(result[0][0], result[0][1].value)],
|
||||
[(defer.FAILURE,
|
||||
component.ComponentException(
|
||||
'Trying to start component "%s" but it is '
|
||||
'not in a stopped state. Current state: %s' %
|
||||
('test_pause_c1', 'Paused'), ''))])
|
||||
|
||||
def test_shutdown(self):
|
||||
def on_shutdown(result, c1):
|
||||
self.assertTrue(c1.shutdowned)
|
||||
self.assertEquals(c1._component_state, 'Stopped')
|
||||
self.assertEquals(c1.stop_count, 1)
|
||||
self.assertEqual(c1._component_state, 'Stopped')
|
||||
self.assertEqual(c1.stop_count, 1)
|
||||
|
||||
def on_start(result, c1):
|
||||
d = component.shutdown()
|
||||
|
||||
@ -26,25 +26,25 @@ class ConfigTestCase(unittest.TestCase):
|
||||
|
||||
def test_init(self):
|
||||
config = Config('test.conf', defaults=DEFAULTS, config_dir=self.config_dir)
|
||||
self.assertEquals(DEFAULTS, config.config)
|
||||
self.assertEqual(DEFAULTS, config.config)
|
||||
|
||||
config = Config('test.conf', config_dir=self.config_dir)
|
||||
self.assertEquals({}, config.config)
|
||||
self.assertEqual({}, config.config)
|
||||
|
||||
def test_set_get_item(self):
|
||||
config = Config('test.conf', config_dir=self.config_dir)
|
||||
config['foo'] = 1
|
||||
self.assertEquals(config['foo'], 1)
|
||||
self.assertEqual(config['foo'], 1)
|
||||
self.assertRaises(ValueError, config.set_item, 'foo', 'bar')
|
||||
|
||||
config['foo'] = 2
|
||||
self.assertEquals(config.get_item('foo'), 2)
|
||||
self.assertEqual(config.get_item('foo'), 2)
|
||||
|
||||
config['foo'] = '3'
|
||||
self.assertEquals(config.get_item('foo'), 3)
|
||||
self.assertEqual(config.get_item('foo'), 3)
|
||||
|
||||
config['unicode'] = 'ВИДЕОФИЛЬМЫ'
|
||||
self.assertEquals(config['unicode'], 'ВИДЕОФИЛЬМЫ')
|
||||
self.assertEqual(config['unicode'], 'ВИДЕОФИЛЬМЫ')
|
||||
|
||||
config['unicode'] = b'foostring'
|
||||
self.assertFalse(isinstance(config.get_item('unicode'), bytes))
|
||||
@ -59,7 +59,7 @@ class ConfigTestCase(unittest.TestCase):
|
||||
self.assertIsInstance(config['foo'], type(None))
|
||||
|
||||
config['foo'] = 1
|
||||
self.assertEquals(config.get('foo'), 1)
|
||||
self.assertEqual(config.get('foo'), 1)
|
||||
|
||||
config['foo'] = None
|
||||
self.assertIsNone(config['foo'])
|
||||
@ -75,18 +75,18 @@ class ConfigTestCase(unittest.TestCase):
|
||||
def test_get(self):
|
||||
config = Config('test.conf', config_dir=self.config_dir)
|
||||
config['foo'] = 1
|
||||
self.assertEquals(config.get('foo'), 1)
|
||||
self.assertEquals(config.get('foobar'), None)
|
||||
self.assertEquals(config.get('foobar', 2), 2)
|
||||
self.assertEqual(config.get('foo'), 1)
|
||||
self.assertEqual(config.get('foobar'), None)
|
||||
self.assertEqual(config.get('foobar', 2), 2)
|
||||
config['foobar'] = 5
|
||||
self.assertEquals(config.get('foobar', 2), 5)
|
||||
self.assertEqual(config.get('foobar', 2), 5)
|
||||
|
||||
def test_load(self):
|
||||
def check_config():
|
||||
config = Config('test.conf', config_dir=self.config_dir)
|
||||
|
||||
self.assertEquals(config['string'], 'foobar')
|
||||
self.assertEquals(config['float'], 0.435)
|
||||
self.assertEqual(config['string'], 'foobar')
|
||||
self.assertEqual(config['float'], 0.435)
|
||||
|
||||
# Test loading an old config from 1.1.x
|
||||
import pickle
|
||||
@ -135,8 +135,8 @@ class ConfigTestCase(unittest.TestCase):
|
||||
del config
|
||||
|
||||
config = Config('test.conf', defaults=DEFAULTS, config_dir=self.config_dir)
|
||||
self.assertEquals(config['string'], 'baz')
|
||||
self.assertEquals(config['int'], 2)
|
||||
self.assertEqual(config['string'], 'baz')
|
||||
self.assertEqual(config['int'], 2)
|
||||
|
||||
def test_save_timer(self):
|
||||
self.clock = task.Clock()
|
||||
@ -154,8 +154,8 @@ class ConfigTestCase(unittest.TestCase):
|
||||
self.assertTrue(not config._save_timer.active())
|
||||
del config
|
||||
config = Config('test.conf', defaults=DEFAULTS, config_dir=self.config_dir)
|
||||
self.assertEquals(config['string'], 'baz')
|
||||
self.assertEquals(config['int'], 2)
|
||||
self.assertEqual(config['string'], 'baz')
|
||||
self.assertEqual(config['int'], 2)
|
||||
|
||||
check_config(config)
|
||||
|
||||
@ -172,4 +172,4 @@ class ConfigTestCase(unittest.TestCase):
|
||||
from deluge.config import find_json_objects
|
||||
|
||||
objects = find_json_objects(s)
|
||||
self.assertEquals(len(objects), 2)
|
||||
self.assertEqual(len(objects), 2)
|
||||
|
||||
@ -123,7 +123,7 @@ class CoreTestCase(BaseTestCase):
|
||||
filedump = base64.encodestring(_file.read())
|
||||
files_to_add.append((filename, filedump, options))
|
||||
errors = yield self.core.add_torrent_files(files_to_add)
|
||||
self.assertEquals(len(errors), 0)
|
||||
self.assertEqual(len(errors), 0)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def test_add_torrent_files_error_duplicate(self):
|
||||
@ -136,7 +136,7 @@ class CoreTestCase(BaseTestCase):
|
||||
filedump = base64.encodestring(_file.read())
|
||||
files_to_add.append((filename, filedump, options))
|
||||
errors = yield self.core.add_torrent_files(files_to_add)
|
||||
self.assertEquals(len(errors), 1)
|
||||
self.assertEqual(len(errors), 1)
|
||||
self.assertTrue(str(errors[0]).startswith('Torrent already in session'))
|
||||
|
||||
@defer.inlineCallbacks
|
||||
@ -151,7 +151,7 @@ class CoreTestCase(BaseTestCase):
|
||||
from deluge.bencode import bdecode, bencode
|
||||
with open(filename) as _file:
|
||||
info_hash = sha(bencode(bdecode(_file.read())['info'])).hexdigest()
|
||||
self.assertEquals(torrent_id, info_hash)
|
||||
self.assertEqual(torrent_id, info_hash)
|
||||
|
||||
def test_add_torrent_file_invalid_filedump(self):
|
||||
options = {}
|
||||
@ -165,7 +165,7 @@ class CoreTestCase(BaseTestCase):
|
||||
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
|
||||
|
||||
torrent_id = yield self.core.add_torrent_url(url, options)
|
||||
self.assertEquals(torrent_id, info_hash)
|
||||
self.assertEqual(torrent_id, info_hash)
|
||||
|
||||
def test_add_torrent_url_with_cookie(self):
|
||||
url = 'http://localhost:%d/cookie' % self.listen_port
|
||||
@ -177,7 +177,7 @@ class CoreTestCase(BaseTestCase):
|
||||
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,))
|
||||
d.addCallbacks(self.assertEqual, self.fail, callbackArgs=(info_hash,))
|
||||
|
||||
return d
|
||||
|
||||
@ -187,7 +187,7 @@ class CoreTestCase(BaseTestCase):
|
||||
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
|
||||
|
||||
d = self.core.add_torrent_url(url, options)
|
||||
d.addCallback(self.assertEquals, info_hash)
|
||||
d.addCallback(self.assertEqual, info_hash)
|
||||
return d
|
||||
|
||||
def test_add_torrent_url_with_partial_download(self):
|
||||
@ -196,7 +196,7 @@ class CoreTestCase(BaseTestCase):
|
||||
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
|
||||
|
||||
d = self.core.add_torrent_url(url, options)
|
||||
d.addCallback(self.assertEquals, info_hash)
|
||||
d.addCallback(self.assertEqual, info_hash)
|
||||
return d
|
||||
|
||||
@defer.inlineCallbacks
|
||||
@ -205,7 +205,7 @@ class CoreTestCase(BaseTestCase):
|
||||
uri = deluge.common.create_magnet_uri(info_hash)
|
||||
options = {}
|
||||
torrent_id = yield self.core.add_torrent_magnet(uri, options)
|
||||
self.assertEquals(torrent_id, info_hash)
|
||||
self.assertEqual(torrent_id, info_hash)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def test_remove_torrent(self):
|
||||
@ -216,7 +216,7 @@ class CoreTestCase(BaseTestCase):
|
||||
torrent_id = yield self.core.add_torrent_file(filename, filedump, options)
|
||||
removed = self.core.remove_torrent(torrent_id, True)
|
||||
self.assertTrue(removed)
|
||||
self.assertEquals(len(self.core.get_session_state()), 0)
|
||||
self.assertEqual(len(self.core.get_session_state()), 0)
|
||||
|
||||
def test_remove_torrent_invalid(self):
|
||||
self.assertRaises(InvalidTorrentError, self.core.remove_torrent, 'torrentidthatdoesntexist', True)
|
||||
@ -240,7 +240,7 @@ class CoreTestCase(BaseTestCase):
|
||||
d.addCallback(test_ret)
|
||||
|
||||
def test_session_state(val):
|
||||
self.assertEquals(len(self.core.get_session_state()), 0)
|
||||
self.assertEqual(len(self.core.get_session_state()), 0)
|
||||
d.addCallback(test_session_state)
|
||||
yield d
|
||||
|
||||
@ -258,21 +258,21 @@ class CoreTestCase(BaseTestCase):
|
||||
|
||||
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)
|
||||
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.assertEquals(type(status), dict)
|
||||
self.assertEquals(status['write_hit_ratio'], 0.0)
|
||||
self.assertEquals(status['read_hit_ratio'], 0.0)
|
||||
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.assertEquals(self.core.get_free_space('/someinvalidpath'), -1)
|
||||
self.assertEqual(self.core.get_free_space('/someinvalidpath'), -1)
|
||||
|
||||
@pytest.mark.slow
|
||||
def test_test_listen_port(self):
|
||||
@ -297,15 +297,15 @@ class CoreTestCase(BaseTestCase):
|
||||
}
|
||||
|
||||
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] + '/')
|
||||
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.assertEquals(self.core.get_config_values(['abc', 'foo']), {'foo': None, 'abc': None})
|
||||
self.assertEquals(self.core.get_config_value('foobar'), None)
|
||||
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.assertEquals(self.core.get_config_values(['foo', 'abc']), {'foo': 10, 'abc': 'def'})
|
||||
self.assertEquals(self.core.get_config_value('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'
|
||||
@ -314,6 +314,6 @@ class CoreTestCase(BaseTestCase):
|
||||
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.assertEquals(old_value, new_value)
|
||||
self.assertEqual(old_value, new_value)
|
||||
|
||||
self.core.read_only_config_keys = None
|
||||
|
||||
@ -22,26 +22,26 @@ class ErrorTestCase(unittest.TestCase):
|
||||
def test_deluge_error(self):
|
||||
msg = 'Some message'
|
||||
e = deluge.error.DelugeError(msg)
|
||||
self.assertEquals(str(e), msg)
|
||||
self.assertEqual(str(e), msg)
|
||||
from twisted.internet.defer import DebugInfo
|
||||
del DebugInfo.__del__ # Hides all errors
|
||||
self.assertEquals(e._args, (msg,))
|
||||
self.assertEquals(e._kwargs, {})
|
||||
self.assertEqual(e._args, (msg,))
|
||||
self.assertEqual(e._kwargs, {})
|
||||
|
||||
def test_incompatible_client(self):
|
||||
version = '1.3.6'
|
||||
e = deluge.error.IncompatibleClient(version)
|
||||
self.assertEquals(str(e), 'Your deluge client is not compatible with the daemon. \
|
||||
self.assertEqual(str(e), 'Your deluge client is not compatible with the daemon. \
|
||||
Please upgrade your client to %s' % version)
|
||||
|
||||
def test_not_authorized_error(self):
|
||||
current_level = 5
|
||||
required_level = 10
|
||||
e = deluge.error.NotAuthorizedError(current_level, required_level)
|
||||
self.assertEquals(str(e), 'Auth level too low: %d < %d' % (current_level, required_level))
|
||||
self.assertEqual(str(e), 'Auth level too low: %d < %d' % (current_level, required_level))
|
||||
|
||||
def test_bad_login_error(self):
|
||||
message = 'Login failed'
|
||||
username = 'deluge'
|
||||
e = deluge.error.BadLoginError(message, username)
|
||||
self.assertEquals(str(e), message)
|
||||
self.assertEqual(str(e), message)
|
||||
|
||||
@ -145,10 +145,10 @@ class DownloadFileTestCase(unittest.TestCase):
|
||||
self.fail(ex)
|
||||
return filename
|
||||
|
||||
def failIfContains(self, filename, contents): # NOQA
|
||||
def assertNotContains(self, filename, contents): # NOQA
|
||||
with open(filename) as _file:
|
||||
try:
|
||||
self.failIfEqual(_file.read(), contents)
|
||||
self.assertNotEqual(_file.read(), contents)
|
||||
except Exception as ex:
|
||||
self.fail(ex)
|
||||
return filename
|
||||
@ -211,7 +211,7 @@ class DownloadFileTestCase(unittest.TestCase):
|
||||
def test_download_with_gzip_encoding_disabled(self):
|
||||
url = self.get_url('gzip?msg=fail')
|
||||
d = download_file(url, fname('gzip_encoded'), allow_compression=False)
|
||||
d.addCallback(self.failIfContains, b'fail')
|
||||
d.addCallback(self.assertNotContains, b'fail')
|
||||
return d
|
||||
|
||||
def test_page_redirect_unhandled(self):
|
||||
|
||||
@ -63,7 +63,7 @@ class JSONTestCase(JSONBase):
|
||||
def test_get_remote_methods(self):
|
||||
json = JSON()
|
||||
methods = yield json.get_remote_methods()
|
||||
self.assertEquals(type(methods), tuple)
|
||||
self.assertEqual(type(methods), tuple)
|
||||
self.assertTrue(len(methods) > 0)
|
||||
|
||||
def test_render_fail_disconnected(self):
|
||||
@ -72,7 +72,7 @@ class JSONTestCase(JSONBase):
|
||||
request.method = 'POST'
|
||||
request._disconnected = True
|
||||
# When disconnected, returns empty string
|
||||
self.assertEquals(json.render(request), '')
|
||||
self.assertEqual(json.render(request), '')
|
||||
|
||||
def test_render_fail(self):
|
||||
json = JSON()
|
||||
@ -86,16 +86,16 @@ class JSONTestCase(JSONBase):
|
||||
def write(response_str):
|
||||
request.write_was_called = True
|
||||
response = json_lib.loads(response_str)
|
||||
self.assertEquals(response['result'], None)
|
||||
self.assertEquals(response['id'], None)
|
||||
self.assertEquals(response['error']['message'], 'JSONException: JSON not decodable')
|
||||
self.assertEquals(response['error']['code'], 5)
|
||||
self.assertEqual(response['result'], None)
|
||||
self.assertEqual(response['id'], None)
|
||||
self.assertEqual(response['error']['message'], 'JSONException: JSON not decodable')
|
||||
self.assertEqual(response['error']['code'], 5)
|
||||
|
||||
request.write = write
|
||||
request.write_was_called = False
|
||||
request._disconnected = False
|
||||
request.getHeader.return_value = 'application/json'
|
||||
self.assertEquals(json.render(request), server.NOT_DONE_YET)
|
||||
self.assertEqual(json.render(request), server.NOT_DONE_YET)
|
||||
self.assertTrue(request.write_was_called)
|
||||
|
||||
def test_handle_request_invalid_method(self):
|
||||
@ -104,7 +104,7 @@ class JSONTestCase(JSONBase):
|
||||
json_data = {'method': 'no-existing-module.test', 'id': 0, 'params': []}
|
||||
request.json = json_lib.dumps(json_data)
|
||||
request_id, result, error = json._handle_request(request)
|
||||
self.assertEquals(error, {'message': 'Unknown method', 'code': 2})
|
||||
self.assertEqual(error, {'message': 'Unknown method', 'code': 2})
|
||||
|
||||
def test_handle_request_invalid_json_request(self):
|
||||
json = JSON()
|
||||
@ -148,7 +148,7 @@ class JSONCustomUserTestCase(JSONBase):
|
||||
json_data = {'method': 'core.get_libtorrent_version', 'id': 0, 'params': []}
|
||||
request.json = json_lib.dumps(json_data)
|
||||
request_id, result, error = json._handle_request(request)
|
||||
self.assertEquals(error, {'message': 'Not authenticated', 'code': 1})
|
||||
self.assertEqual(error, {'message': 'Not authenticated', 'code': 1})
|
||||
|
||||
|
||||
class RPCRaiseDelugeErrorJSONTestCase(JSONBase):
|
||||
@ -194,7 +194,7 @@ class RPCRaiseDelugeErrorJSONTestCase(JSONBase):
|
||||
result.addCallback(self.fail)
|
||||
|
||||
def on_error(error):
|
||||
self.assertEquals(error.type, DelugeError)
|
||||
self.assertEqual(error.type, DelugeError)
|
||||
result.addErrback(on_error)
|
||||
yield result
|
||||
|
||||
@ -252,12 +252,13 @@ class JSONRequestFailedTestCase(JSONBase, WebServerMockBase):
|
||||
def write(response_str):
|
||||
request.write_was_called = True
|
||||
response = json_lib.loads(response_str)
|
||||
self.assertEquals(response['result'], None, 'BAD RESULT')
|
||||
self.assertEquals(response['id'], 0)
|
||||
self.assertEquals(response['error']['message'],
|
||||
'Failure: [Failure instance: Traceback (failure with no frames):'
|
||||
" <class 'deluge.error.DelugeError'>: DelugeERROR\n]")
|
||||
self.assertEquals(response['error']['code'], 4)
|
||||
self.assertEqual(response['result'], None, 'BAD RESULT')
|
||||
self.assertEqual(response['id'], 0)
|
||||
self.assertEqual(
|
||||
response['error']['message'],
|
||||
'Failure: [Failure instance: Traceback (failure with no frames):'
|
||||
" <class 'deluge.error.DelugeError'>: DelugeERROR\n]")
|
||||
self.assertEqual(response['error']['code'], 4)
|
||||
|
||||
request.write = write
|
||||
request.write_was_called = False
|
||||
@ -268,7 +269,7 @@ class JSONRequestFailedTestCase(JSONBase, WebServerMockBase):
|
||||
d = json._on_json_request(request)
|
||||
|
||||
def on_success(arg):
|
||||
self.assertEquals(arg, server.NOT_DONE_YET)
|
||||
self.assertEqual(arg, server.NOT_DONE_YET)
|
||||
return True
|
||||
d.addCallbacks(on_success, self.fail)
|
||||
yield d
|
||||
|
||||
@ -59,24 +59,24 @@ class RPCServerTestCase(BaseTestCase):
|
||||
e = TorrentFolderRenamedEvent(*data)
|
||||
self.rpcserver.emit_event_for_session_id(self.session_id, e)
|
||||
msg = self.protocol.messages.pop()
|
||||
self.assertEquals(msg[0], rpcserver.RPC_EVENT, str(msg))
|
||||
self.assertEquals(msg[1], 'TorrentFolderRenamedEvent', str(msg))
|
||||
self.assertEquals(msg[2], data, str(msg))
|
||||
self.assertEqual(msg[0], rpcserver.RPC_EVENT, str(msg))
|
||||
self.assertEqual(msg[1], 'TorrentFolderRenamedEvent', str(msg))
|
||||
self.assertEqual(msg[2], data, str(msg))
|
||||
|
||||
def test_invalid_client_login(self):
|
||||
self.protocol.dispatch(self.request_id, 'daemon.login', [1], {})
|
||||
msg = self.protocol.messages.pop()
|
||||
self.assertEquals(msg[0], rpcserver.RPC_ERROR)
|
||||
self.assertEquals(msg[1], self.request_id)
|
||||
self.assertEqual(msg[0], rpcserver.RPC_ERROR)
|
||||
self.assertEqual(msg[1], self.request_id)
|
||||
|
||||
def test_valid_client_login(self):
|
||||
self.authmanager = AuthManager()
|
||||
auth = get_localhost_auth()
|
||||
self.protocol.dispatch(self.request_id, 'daemon.login', auth, {'client_version': 'Test'})
|
||||
msg = self.protocol.messages.pop()
|
||||
self.assertEquals(msg[0], rpcserver.RPC_RESPONSE, str(msg))
|
||||
self.assertEquals(msg[1], self.request_id, str(msg))
|
||||
self.assertEquals(msg[2], rpcserver.AUTH_LEVEL_ADMIN, str(msg))
|
||||
self.assertEqual(msg[0], rpcserver.RPC_RESPONSE, str(msg))
|
||||
self.assertEqual(msg[1], self.request_id, str(msg))
|
||||
self.assertEqual(msg[2], rpcserver.AUTH_LEVEL_ADMIN, str(msg))
|
||||
|
||||
def test_client_login_error(self):
|
||||
# This test causes error log prints while running the test...
|
||||
@ -85,24 +85,24 @@ class RPCServerTestCase(BaseTestCase):
|
||||
auth = get_localhost_auth()
|
||||
self.protocol.dispatch(self.request_id, 'daemon.login', auth, {'client_version': 'Test'})
|
||||
msg = self.protocol.messages.pop()
|
||||
self.assertEquals(msg[0], rpcserver.RPC_ERROR)
|
||||
self.assertEquals(msg[1], self.request_id)
|
||||
self.assertEquals(msg[2], 'WrappedException')
|
||||
self.assertEquals(msg[3][1], 'AttributeError')
|
||||
self.assertEqual(msg[0], rpcserver.RPC_ERROR)
|
||||
self.assertEqual(msg[1], self.request_id)
|
||||
self.assertEqual(msg[2], 'WrappedException')
|
||||
self.assertEqual(msg[3][1], 'AttributeError')
|
||||
|
||||
def test_client_invalid_method_call(self):
|
||||
self.authmanager = AuthManager()
|
||||
auth = get_localhost_auth()
|
||||
self.protocol.dispatch(self.request_id, 'invalid_function', auth, {})
|
||||
msg = self.protocol.messages.pop()
|
||||
self.assertEquals(msg[0], rpcserver.RPC_ERROR)
|
||||
self.assertEquals(msg[1], self.request_id)
|
||||
self.assertEquals(msg[2], 'WrappedException')
|
||||
self.assertEquals(msg[3][1], 'AttributeError')
|
||||
self.assertEqual(msg[0], rpcserver.RPC_ERROR)
|
||||
self.assertEqual(msg[1], self.request_id)
|
||||
self.assertEqual(msg[2], 'WrappedException')
|
||||
self.assertEqual(msg[3][1], 'AttributeError')
|
||||
|
||||
def test_daemon_info(self):
|
||||
self.protocol.dispatch(self.request_id, 'daemon.info', [], {})
|
||||
msg = self.protocol.messages.pop()
|
||||
self.assertEquals(msg[0], rpcserver.RPC_RESPONSE, str(msg))
|
||||
self.assertEquals(msg[1], self.request_id, str(msg))
|
||||
self.assertEquals(msg[2], deluge.common.get_version(), str(msg))
|
||||
self.assertEqual(msg[0], rpcserver.RPC_RESPONSE, str(msg))
|
||||
self.assertEqual(msg[1], self.request_id, str(msg))
|
||||
self.assertEqual(msg[2], deluge.common.get_version(), str(msg))
|
||||
|
||||
@ -122,24 +122,24 @@ class SessionProxyTestCase(BaseTestCase):
|
||||
return component.deregister(self.sp)
|
||||
|
||||
def test_startup(self):
|
||||
self.assertEquals(client.core.torrents['a'], self.sp.torrents['a'][1])
|
||||
self.assertEqual(client.core.torrents['a'], self.sp.torrents['a'][1])
|
||||
|
||||
def test_get_torrent_status_no_change(self):
|
||||
d = self.sp.get_torrent_status('a', [])
|
||||
d.addCallback(self.assertEquals, client.core.torrents['a'])
|
||||
d.addCallback(self.assertEqual, client.core.torrents['a'])
|
||||
return d
|
||||
|
||||
def test_get_torrent_status_change_with_cache(self):
|
||||
client.core.torrents['a']['key1'] = 2
|
||||
d = self.sp.get_torrent_status('a', ['key1'])
|
||||
d.addCallback(self.assertEquals, {'key1': 1})
|
||||
d.addCallback(self.assertEqual, {'key1': 1})
|
||||
return d
|
||||
|
||||
def test_get_torrent_status_change_without_cache(self):
|
||||
client.core.torrents['a']['key1'] = 2
|
||||
self.clock.advance(self.sp.cache_time + 0.1)
|
||||
d = self.sp.get_torrent_status('a', [])
|
||||
d.addCallback(self.assertEquals, client.core.torrents['a'])
|
||||
d.addCallback(self.assertEqual, client.core.torrents['a'])
|
||||
return d
|
||||
|
||||
def test_get_torrent_status_key_not_updated(self):
|
||||
@ -147,7 +147,7 @@ class SessionProxyTestCase(BaseTestCase):
|
||||
self.sp.get_torrent_status('a', ['key1'])
|
||||
client.core.torrents['a']['key2'] = 99
|
||||
d = self.sp.get_torrent_status('a', ['key2'])
|
||||
d.addCallback(self.assertEquals, {'key2': 99})
|
||||
d.addCallback(self.assertEqual, {'key2': 99})
|
||||
return d
|
||||
|
||||
def test_get_torrents_status_key_not_updated(self):
|
||||
@ -155,5 +155,5 @@ class SessionProxyTestCase(BaseTestCase):
|
||||
self.sp.get_torrents_status({'id': ['a']}, ['key1'])
|
||||
client.core.torrents['a']['key2'] = 99
|
||||
d = self.sp.get_torrents_status({'id': ['a']}, ['key2'])
|
||||
d.addCallback(self.assertEquals, {'a': {'key2': 99}})
|
||||
d.addCallback(self.assertEqual, {'a': {'key2': 99}})
|
||||
return d
|
||||
|
||||
@ -57,7 +57,7 @@ class TorrentTestCase(BaseTestCase):
|
||||
|
||||
def assert_state(self, torrent, state):
|
||||
torrent.update_state()
|
||||
self.assertEquals(torrent.state, state)
|
||||
self.assertEqual(torrent.state, state)
|
||||
|
||||
def get_torrent_atp(self, filename):
|
||||
filename = common.get_test_data_file(filename)
|
||||
@ -86,14 +86,14 @@ class TorrentTestCase(BaseTestCase):
|
||||
priorities = handle.piece_priorities()
|
||||
|
||||
# The length of the list of new priorites is the same as the original
|
||||
self.assertEquals(len(priorities_original), len(priorities))
|
||||
self.assertEqual(len(priorities_original), len(priorities))
|
||||
|
||||
# Test the priority of all the pieces against the calculated indexes.
|
||||
for idx, priority in enumerate(priorities):
|
||||
if idx in prioritized_piece_indexes:
|
||||
self.assertEquals(priorities[idx], 7)
|
||||
self.assertEqual(priorities[idx], 7)
|
||||
else:
|
||||
self.assertEquals(priorities[idx], 4)
|
||||
self.assertEqual(priorities[idx], 4)
|
||||
|
||||
# self.print_priority_list(priorities)
|
||||
|
||||
@ -109,7 +109,7 @@ class TorrentTestCase(BaseTestCase):
|
||||
|
||||
# Test the priority of the prioritized pieces
|
||||
for i in priorities:
|
||||
self.assertEquals(priorities[i], 4)
|
||||
self.assertEqual(priorities[i], 4)
|
||||
|
||||
# self.print_priority_list(priorities)
|
||||
|
||||
@ -188,7 +188,7 @@ class TorrentTestCase(BaseTestCase):
|
||||
def assert_resume_data():
|
||||
self.assert_state(torrent, 'Error')
|
||||
tm_resume_data = lt.bdecode(self.core.torrentmanager.resume_data[torrent.torrent_id])
|
||||
self.assertEquals(tm_resume_data, resume_data)
|
||||
self.assertEqual(tm_resume_data, resume_data)
|
||||
|
||||
yield deferLater(reactor, 0.5, assert_resume_data)
|
||||
return
|
||||
|
||||
@ -80,21 +80,21 @@ class TorrentviewTestCase(BaseTestCase):
|
||||
|
||||
def test_torrentview_columns(self):
|
||||
|
||||
self.assertEquals(self.torrentview.column_index, TorrentviewTestCase.default_column_index)
|
||||
self.assertEquals(self.torrentview.liststore_columns, TorrentviewTestCase.default_liststore_columns)
|
||||
self.assertEquals(self.torrentview.columns['Download Folder'].column_indices, [29])
|
||||
self.assertEqual(self.torrentview.column_index, TorrentviewTestCase.default_column_index)
|
||||
self.assertEqual(self.torrentview.liststore_columns, TorrentviewTestCase.default_liststore_columns)
|
||||
self.assertEqual(self.torrentview.columns['Download Folder'].column_indices, [29])
|
||||
|
||||
def test_add_column(self):
|
||||
|
||||
# Add a text column
|
||||
test_col = 'Test column'
|
||||
self.torrentview.add_text_column(test_col, status_field=['label'])
|
||||
self.assertEquals(len(self.torrentview.liststore_columns),
|
||||
len(TorrentviewTestCase.default_liststore_columns) + 1)
|
||||
self.assertEquals(len(self.torrentview.column_index),
|
||||
len(TorrentviewTestCase.default_column_index) + 1)
|
||||
self.assertEquals(self.torrentview.column_index[-1], test_col)
|
||||
self.assertEquals(self.torrentview.columns[test_col].column_indices, [32])
|
||||
self.assertEqual(len(self.torrentview.liststore_columns),
|
||||
len(TorrentviewTestCase.default_liststore_columns) + 1)
|
||||
self.assertEqual(len(self.torrentview.column_index),
|
||||
len(TorrentviewTestCase.default_column_index) + 1)
|
||||
self.assertEqual(self.torrentview.column_index[-1], test_col)
|
||||
self.assertEqual(self.torrentview.columns[test_col].column_indices, [32])
|
||||
|
||||
def test_add_columns(self):
|
||||
|
||||
@ -106,17 +106,17 @@ class TorrentviewTestCase(BaseTestCase):
|
||||
test_col2 = 'Test column2'
|
||||
self.torrentview.add_text_column(test_col2, status_field=['label2'])
|
||||
|
||||
self.assertEquals(len(self.torrentview.liststore_columns),
|
||||
len(TorrentviewTestCase.default_liststore_columns) + 2)
|
||||
self.assertEquals(len(self.torrentview.column_index),
|
||||
len(TorrentviewTestCase.default_column_index) + 2)
|
||||
self.assertEqual(len(self.torrentview.liststore_columns),
|
||||
len(TorrentviewTestCase.default_liststore_columns) + 2)
|
||||
self.assertEqual(len(self.torrentview.column_index),
|
||||
len(TorrentviewTestCase.default_column_index) + 2)
|
||||
# test_col
|
||||
self.assertEquals(self.torrentview.column_index[-2], test_col)
|
||||
self.assertEquals(self.torrentview.columns[test_col].column_indices, [32])
|
||||
self.assertEqual(self.torrentview.column_index[-2], test_col)
|
||||
self.assertEqual(self.torrentview.columns[test_col].column_indices, [32])
|
||||
|
||||
# test_col2
|
||||
self.assertEquals(self.torrentview.column_index[-1], test_col2)
|
||||
self.assertEquals(self.torrentview.columns[test_col2].column_indices, [33])
|
||||
self.assertEqual(self.torrentview.column_index[-1], test_col2)
|
||||
self.assertEqual(self.torrentview.columns[test_col2].column_indices, [33])
|
||||
|
||||
def test_remove_column(self):
|
||||
|
||||
@ -125,10 +125,10 @@ class TorrentviewTestCase(BaseTestCase):
|
||||
self.torrentview.add_text_column(test_col, status_field=['label'])
|
||||
self.torrentview.remove_column(test_col)
|
||||
|
||||
self.assertEquals(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
|
||||
self.assertEquals(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
|
||||
self.assertEquals(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1])
|
||||
self.assertEquals(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])
|
||||
self.assertEqual(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
|
||||
self.assertEqual(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
|
||||
self.assertEqual(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1])
|
||||
self.assertEqual(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])
|
||||
|
||||
def test_remove_columns(self):
|
||||
|
||||
@ -140,36 +140,36 @@ class TorrentviewTestCase(BaseTestCase):
|
||||
|
||||
# Remove test_col
|
||||
self.torrentview.remove_column(test_col)
|
||||
self.assertEquals(len(self.torrentview.liststore_columns),
|
||||
len(TorrentviewTestCase.default_liststore_columns) + 1)
|
||||
self.assertEquals(len(self.torrentview.column_index),
|
||||
len(TorrentviewTestCase.default_column_index) + 1)
|
||||
self.assertEquals(self.torrentview.column_index[-1], test_col2)
|
||||
self.assertEquals(self.torrentview.columns[test_col2].column_indices, [32])
|
||||
self.assertEqual(len(self.torrentview.liststore_columns),
|
||||
len(TorrentviewTestCase.default_liststore_columns) + 1)
|
||||
self.assertEqual(len(self.torrentview.column_index),
|
||||
len(TorrentviewTestCase.default_column_index) + 1)
|
||||
self.assertEqual(self.torrentview.column_index[-1], test_col2)
|
||||
self.assertEqual(self.torrentview.columns[test_col2].column_indices, [32])
|
||||
|
||||
# Remove test_col2
|
||||
self.torrentview.remove_column(test_col2)
|
||||
self.assertEquals(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
|
||||
self.assertEquals(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
|
||||
self.assertEquals(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1])
|
||||
self.assertEquals(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])
|
||||
self.assertEqual(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
|
||||
self.assertEqual(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
|
||||
self.assertEqual(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1])
|
||||
self.assertEqual(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])
|
||||
|
||||
def test_add_remove_column_multiple_types(self):
|
||||
|
||||
# Add a column with multiple column types
|
||||
test_col3 = 'Test column3'
|
||||
self.torrentview.add_progress_column(test_col3, status_field=['progress', 'label3'], col_types=[float, str])
|
||||
self.assertEquals(len(self.torrentview.liststore_columns),
|
||||
len(TorrentviewTestCase.default_liststore_columns) + 2)
|
||||
self.assertEquals(len(self.torrentview.column_index),
|
||||
len(TorrentviewTestCase.default_column_index) + 1)
|
||||
self.assertEquals(self.torrentview.column_index[-1], test_col3)
|
||||
self.assertEquals(self.torrentview.columns[test_col3].column_indices, [32, 33])
|
||||
self.assertEqual(len(self.torrentview.liststore_columns),
|
||||
len(TorrentviewTestCase.default_liststore_columns) + 2)
|
||||
self.assertEqual(len(self.torrentview.column_index),
|
||||
len(TorrentviewTestCase.default_column_index) + 1)
|
||||
self.assertEqual(self.torrentview.column_index[-1], test_col3)
|
||||
self.assertEqual(self.torrentview.columns[test_col3].column_indices, [32, 33])
|
||||
|
||||
# Remove multiple column-types column
|
||||
self.torrentview.remove_column(test_col3)
|
||||
|
||||
self.assertEquals(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
|
||||
self.assertEquals(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
|
||||
self.assertEquals(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1])
|
||||
self.assertEquals(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])
|
||||
self.assertEqual(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
|
||||
self.assertEqual(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
|
||||
self.assertEqual(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1])
|
||||
self.assertEqual(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])
|
||||
|
||||
@ -35,7 +35,7 @@ class TrackerIconsTestCase(BaseTestCase):
|
||||
icon = TrackerIcon(common.get_test_data_file('deluge.png'))
|
||||
d = self.icons.fetch('deluge-torrent.org')
|
||||
d.addCallback(self.assertNotIdentical, None)
|
||||
d.addCallback(self.assertEquals, icon)
|
||||
d.addCallback(self.assertEqual, icon)
|
||||
return d
|
||||
|
||||
def test_get_google_ico(self):
|
||||
@ -44,7 +44,7 @@ class TrackerIconsTestCase(BaseTestCase):
|
||||
icon = TrackerIcon(common.get_test_data_file('google.ico'))
|
||||
d = self.icons.fetch('www.google.com')
|
||||
d.addCallback(self.assertNotIdentical, None)
|
||||
d.addCallback(self.assertEquals, icon)
|
||||
d.addCallback(self.assertEqual, icon)
|
||||
return d
|
||||
|
||||
def test_get_google_ico_with_redirect(self):
|
||||
@ -52,7 +52,7 @@ class TrackerIconsTestCase(BaseTestCase):
|
||||
icon = TrackerIcon(common.get_test_data_file('google.ico'))
|
||||
d = self.icons.fetch('google.com')
|
||||
d.addCallback(self.assertNotIdentical, None)
|
||||
d.addCallback(self.assertEquals, icon)
|
||||
d.addCallback(self.assertEqual, icon)
|
||||
return d
|
||||
|
||||
def test_get_ubuntu_ico(self):
|
||||
@ -60,7 +60,7 @@ class TrackerIconsTestCase(BaseTestCase):
|
||||
icon = TrackerIcon(common.get_test_data_file('ubuntu.png'))
|
||||
d = self.icons.fetch('www.ubuntu.com')
|
||||
d.addCallback(self.assertNotIdentical, None)
|
||||
d.addCallback(self.assertEquals, icon)
|
||||
d.addCallback(self.assertEqual, icon)
|
||||
return d
|
||||
|
||||
def test_get_empty_string_tracker(self):
|
||||
|
||||
@ -141,7 +141,7 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
|
||||
# Get the data as sent by DelugeTransferProtocol
|
||||
messages = self.transfer.get_messages_out_joined()
|
||||
base64_encoded = base64.b64encode(messages)
|
||||
self.assertEquals(base64_encoded, self.msg1_expected_compressed_base64)
|
||||
self.assertEqual(base64_encoded, self.msg1_expected_compressed_base64)
|
||||
|
||||
def test_receive_one_message(self):
|
||||
"""
|
||||
@ -152,7 +152,7 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
|
||||
self.transfer.dataReceived(base64.b64decode(self.msg1_expected_compressed_base64))
|
||||
# Get the data as sent by DelugeTransferProtocol
|
||||
messages = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg1), rencode.dumps(messages))
|
||||
self.assertEqual(rencode.dumps(self.msg1), rencode.dumps(messages))
|
||||
|
||||
def test_receive_old_message(self):
|
||||
"""
|
||||
@ -160,9 +160,9 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
|
||||
|
||||
"""
|
||||
self.transfer.dataReceived(rencode.dumps(self.msg1))
|
||||
self.assertEquals(len(self.transfer.get_messages_in()), 0)
|
||||
self.assertEquals(self.transfer._message_length, 0)
|
||||
self.assertEquals(len(self.transfer._buffer), 0)
|
||||
self.assertEqual(len(self.transfer.get_messages_in()), 0)
|
||||
self.assertEqual(self.transfer._message_length, 0)
|
||||
self.assertEqual(len(self.transfer._buffer), 0)
|
||||
|
||||
def test_receive_two_concatenated_messages(self):
|
||||
"""
|
||||
@ -176,9 +176,9 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
|
||||
|
||||
# Get the data as sent by DelugeTransferProtocol
|
||||
message1 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg1), rencode.dumps(message1))
|
||||
self.assertEqual(rencode.dumps(self.msg1), rencode.dumps(message1))
|
||||
message2 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg2), rencode.dumps(message2))
|
||||
self.assertEqual(rencode.dumps(self.msg2), rencode.dumps(message2))
|
||||
|
||||
def test_receive_three_messages_in_parts(self):
|
||||
"""
|
||||
@ -209,15 +209,15 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
|
||||
else:
|
||||
expected_msgs_received_count = 0
|
||||
# Verify that the expected number of complete messages has arrived
|
||||
self.assertEquals(expected_msgs_received_count, len(self.transfer.get_messages_in()))
|
||||
self.assertEqual(expected_msgs_received_count, len(self.transfer.get_messages_in()))
|
||||
|
||||
# Get the data as received by DelugeTransferProtocol
|
||||
message1 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg1), rencode.dumps(message1))
|
||||
self.assertEqual(rencode.dumps(self.msg1), rencode.dumps(message1))
|
||||
message2 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg2), rencode.dumps(message2))
|
||||
self.assertEqual(rencode.dumps(self.msg2), rencode.dumps(message2))
|
||||
message3 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg1), rencode.dumps(message3))
|
||||
self.assertEqual(rencode.dumps(self.msg1), rencode.dumps(message3))
|
||||
|
||||
# Remove underscore to enable test, or run the test directly:
|
||||
# tests $ trial test_transfer.DelugeTransferProtocolTestCase._test_rencode_fail_protocol
|
||||
@ -265,11 +265,11 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
|
||||
|
||||
# Get the data as received by DelugeTransferProtocol
|
||||
message1 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg1), rencode.dumps(message1))
|
||||
self.assertEqual(rencode.dumps(self.msg1), rencode.dumps(message1))
|
||||
message2 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg2), rencode.dumps(message2))
|
||||
self.assertEqual(rencode.dumps(self.msg2), rencode.dumps(message2))
|
||||
message3 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg1), rencode.dumps(message3))
|
||||
self.assertEqual(rencode.dumps(self.msg1), rencode.dumps(message3))
|
||||
|
||||
def test_receive_middle_of_header(self):
|
||||
"""
|
||||
@ -291,19 +291,19 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
|
||||
self.transfer.dataReceived(two_concatenated[:first_len + 2])
|
||||
|
||||
# Should be 1 message in the list
|
||||
self.assertEquals(1, len(self.transfer.get_messages_in()))
|
||||
self.assertEqual(1, len(self.transfer.get_messages_in()))
|
||||
|
||||
# Send the rest
|
||||
self.transfer.dataReceived(two_concatenated[first_len + 2:])
|
||||
|
||||
# Should be 2 messages in the list
|
||||
self.assertEquals(2, len(self.transfer.get_messages_in()))
|
||||
self.assertEqual(2, len(self.transfer.get_messages_in()))
|
||||
|
||||
# Get the data as sent by DelugeTransferProtocol
|
||||
message1 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg1), rencode.dumps(message1))
|
||||
self.assertEqual(rencode.dumps(self.msg1), rencode.dumps(message1))
|
||||
message2 = self.transfer.get_messages_in().pop(0)
|
||||
self.assertEquals(rencode.dumps(self.msg2), rencode.dumps(message2))
|
||||
self.assertEqual(rencode.dumps(self.msg2), rencode.dumps(message2))
|
||||
|
||||
# Needs file containing big data structure e.g. like thetorrent list as it is transfered by the daemon
|
||||
# def test_simulate_big_transfer(self):
|
||||
@ -321,13 +321,13 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
|
||||
# for d in self.receive_parts_helper(compressed_data, packet_size):
|
||||
# bytes_recv = self.transfer.get_bytes_recv()
|
||||
# if bytes_recv < len(compressed_data):
|
||||
# self.assertEquals(len(self.transfer.get_messages_in()), 0)
|
||||
# self.assertEqual(len(self.transfer.get_messages_in()), 0)
|
||||
# else:
|
||||
# self.assertEquals(len(self.transfer.get_messages_in()), 1)
|
||||
# self.assertEqual(len(self.transfer.get_messages_in()), 1)
|
||||
# Get the data as received by DelugeTransferProtocol
|
||||
# transfered_message = self.transfer.get_messages_in().pop(0)
|
||||
# Test that the data structures are equal
|
||||
# self.assertEquals(transfered_message, message_to_send)
|
||||
# self.assertEqual(transfered_message, message_to_send)
|
||||
# self.assertTrue(transfered_message == message_to_send)
|
||||
#
|
||||
# f.close()
|
||||
|
||||
@ -38,7 +38,7 @@ class WebAPITestCase(WebServerTestBase):
|
||||
d = self.deluge_web.web_api.connect(self.host_id)
|
||||
|
||||
def on_connect(result):
|
||||
self.assertEquals(type(result), tuple)
|
||||
self.assertEqual(type(result), tuple)
|
||||
self.assertTrue(len(result) > 0)
|
||||
self.addCleanup(client.disconnect)
|
||||
return result
|
||||
@ -62,7 +62,7 @@ class WebAPITestCase(WebServerTestBase):
|
||||
|
||||
def test_get_config(self):
|
||||
config = self.deluge_web.web_api.get_config()
|
||||
self.assertEquals(self.webserver_listen_port, config['port'])
|
||||
self.assertEqual(self.webserver_listen_port, config['port'])
|
||||
|
||||
def test_set_config(self):
|
||||
config = self.deluge_web.web_api.get_config()
|
||||
@ -87,35 +87,35 @@ class WebAPITestCase(WebServerTestBase):
|
||||
host[3] = 'Online'
|
||||
host[4] = '2.0.0.dev562'
|
||||
status = yield self.deluge_web.web_api.get_host_status(self.host_id)
|
||||
self.assertEquals(status, tuple(status))
|
||||
self.assertEqual(status, tuple(status))
|
||||
|
||||
def test_get_host(self):
|
||||
self.assertFalse(self.deluge_web.web_api._get_host('invalid_id'))
|
||||
conn = self.deluge_web.web_api.host_list['hosts'][0]
|
||||
self.assertEquals(self.deluge_web.web_api._get_host(conn[0]), conn)
|
||||
self.assertEqual(self.deluge_web.web_api._get_host(conn[0]), conn)
|
||||
|
||||
def test_add_host(self):
|
||||
conn = [None, '', 0, '', '']
|
||||
self.assertFalse(self.deluge_web.web_api._get_host(conn[0]))
|
||||
# Add valid host
|
||||
ret = self.deluge_web.web_api.add_host(conn[1], conn[2], conn[3], conn[4])
|
||||
self.assertEquals(ret[0], True)
|
||||
self.assertEqual(ret[0], True)
|
||||
conn[0] = ret[1]
|
||||
self.assertEquals(self.deluge_web.web_api._get_host(conn[0]), conn)
|
||||
self.assertEqual(self.deluge_web.web_api._get_host(conn[0]), conn)
|
||||
|
||||
# Add already existing host
|
||||
ret = self.deluge_web.web_api.add_host(conn[1], conn[2], conn[3], conn[4])
|
||||
self.assertEquals(ret, (False, 'Host already in the list'))
|
||||
self.assertEqual(ret, (False, 'Host already in the list'))
|
||||
|
||||
# Add invalid port
|
||||
conn[2] = 'bad port'
|
||||
ret = self.deluge_web.web_api.add_host(conn[1], conn[2], conn[3], conn[4])
|
||||
self.assertEquals(ret, (False, 'Port is invalid'))
|
||||
self.assertEqual(ret, (False, 'Port is invalid'))
|
||||
|
||||
def test_remove_host(self):
|
||||
conn = ['connection_id', '', 0, '', '']
|
||||
self.deluge_web.web_api.host_list['hosts'].append(conn)
|
||||
self.assertEquals(self.deluge_web.web_api._get_host(conn[0]), conn)
|
||||
self.assertEqual(self.deluge_web.web_api._get_host(conn[0]), conn)
|
||||
# Remove valid host
|
||||
self.assertTrue(self.deluge_web.web_api.remove_host(conn[0]))
|
||||
self.assertFalse(self.deluge_web.web_api._get_host(conn[0]))
|
||||
@ -125,14 +125,14 @@ class WebAPITestCase(WebServerTestBase):
|
||||
def test_get_torrent_info(self):
|
||||
filename = common.get_test_data_file('test.torrent')
|
||||
ret = self.deluge_web.web_api.get_torrent_info(filename)
|
||||
self.assertEquals(ret['name'], 'azcvsupdater_2.6.2.jar')
|
||||
self.assertEquals(ret['info_hash'], 'ab570cdd5a17ea1b61e970bb72047de141bce173')
|
||||
self.assertEqual(ret['name'], 'azcvsupdater_2.6.2.jar')
|
||||
self.assertEqual(ret['info_hash'], 'ab570cdd5a17ea1b61e970bb72047de141bce173')
|
||||
self.assertTrue('files_tree' in ret)
|
||||
|
||||
def test_get_magnet_info(self):
|
||||
ret = self.deluge_web.web_api.get_magnet_info('magnet:?xt=urn:btih:SU5225URMTUEQLDXQWRB2EQWN6KLTYKN')
|
||||
self.assertEquals(ret['name'], '953bad769164e8482c7785a21d12166f94b9e14d')
|
||||
self.assertEquals(ret['info_hash'], '953bad769164e8482c7785a21d12166f94b9e14d')
|
||||
self.assertEqual(ret['name'], '953bad769164e8482c7785a21d12166f94b9e14d')
|
||||
self.assertEqual(ret['info_hash'], '953bad769164e8482c7785a21d12166f94b9e14d')
|
||||
self.assertTrue('files_tree' in ret)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
@ -142,10 +142,12 @@ class WebAPITestCase(WebServerTestBase):
|
||||
torrents = [{'path': filename, 'options': {'download_location': '/home/deluge/'}}]
|
||||
yield self.deluge_web.web_api.add_torrents(torrents)
|
||||
ret = yield self.deluge_web.web_api.get_torrent_files('ab570cdd5a17ea1b61e970bb72047de141bce173')
|
||||
self.assertEquals(ret['type'], 'dir')
|
||||
self.assertEquals(ret['contents'], {'azcvsupdater_2.6.2.jar':
|
||||
{'priority': 4, 'index': 0, 'offset': 0, 'progress': 0.0, 'path':
|
||||
'azcvsupdater_2.6.2.jar', 'type': 'file', 'size': 307949}})
|
||||
self.assertEqual(ret['type'], 'dir')
|
||||
self.assertEqual(
|
||||
ret['contents'], {
|
||||
'azcvsupdater_2.6.2.jar': {
|
||||
'priority': 4, 'index': 0, 'offset': 0, 'progress': 0.0, 'path':
|
||||
'azcvsupdater_2.6.2.jar', 'type': 'file', 'size': 307949}})
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def test_download_torrent_from_url(self):
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user