mirrors/deluge
0
0
Fork 0
mirror of https://git.deluge-torrent.org/deluge synced 2025-08-13 11:48:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[#2966] [Tests] Rename deprecated method aliases

Browse source
This commit is contained in:
Calum Lind 2017-03-19 22:14:40 +00:00
commit 73ea123f1a
17 changed files with 277 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

4
deluge/tests/test_alertmanager.py
View file

@ -28,7 +28,7 @@ class AlertManagerTestCase(BaseTestCase):
return return
self.am.register_handler('dummy_alert', handler) 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 test_deregister_handler(self):
def handler(alert): def handler(alert):
@ -36,4 +36,4 @@ class AlertManagerTestCase(BaseTestCase):
self.am.register_handler('dummy_alert', handler) self.am.register_handler('dummy_alert', handler)
self.am.deregister_handler(handler) self.am.deregister_handler(handler)
self.assertEquals(self.am.handlers['dummy_alert'], []) self.assertEqual(self.am.handlers['dummy_alert'], [])

2
deluge/tests/test_authmanager.py
View file

@ -24,7 +24,7 @@ class AuthManagerTestCase(BaseTestCase):
def test_authorize(self): def test_authorize(self):
from deluge.ui import common from deluge.ui import common
self.assertEquals( self.assertEqual(
self.auth.authorize(*common.get_localhost_auth()), self.auth.authorize(*common.get_localhost_auth()),
AUTH_LEVEL_ADMIN AUTH_LEVEL_ADMIN
) )

6
deluge/tests/test_client.py
View file

@ -118,7 +118,7 @@ class ClientTestCase(BaseTestCase, DaemonBase):
failure.trap(error.BadLoginError), failure.trap(error.BadLoginError),
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) self.addCleanup(client.disconnect)
d.addCallbacks(self.fail, on_failure) d.addCallbacks(self.fail, on_failure)
@ -133,7 +133,7 @@ class ClientTestCase(BaseTestCase, DaemonBase):
failure.trap(error.BadLoginError), failure.trap(error.BadLoginError),
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) self.addCleanup(client.disconnect)
d.addCallbacks(self.fail, on_failure) d.addCallbacks(self.fail, on_failure)
@ -161,7 +161,7 @@ class ClientTestCase(BaseTestCase, DaemonBase):
yield client.core.create_account('testuser', 'testpw', 'DEFAULT') yield client.core.create_account('testuser', 'testpw', 'DEFAULT')
yield client.disconnect() yield client.disconnect()
ret = yield client.connect('localhost', self.listen_port, username='testuser', password='testpw') 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 yield
@defer.inlineCallbacks @defer.inlineCallbacks

120
deluge/tests/test_common.py
View file

@ -24,91 +24,91 @@ class CommonTestCase(unittest.TestCase):
pass pass
def test_fsize(self): def test_fsize(self):
self.assertEquals(fsize(0), '0 B') self.assertEqual(fsize(0), '0 B')
self.assertEquals(fsize(100), '100 B') self.assertEqual(fsize(100), '100 B')
self.assertEquals(fsize(1023), '1023 B') self.assertEqual(fsize(1023), '1023 B')
self.assertEquals(fsize(1024), '1.0 KiB') self.assertEqual(fsize(1024), '1.0 KiB')
self.assertEquals(fsize(1048575), '1024.0 KiB') self.assertEqual(fsize(1048575), '1024.0 KiB')
self.assertEquals(fsize(1048576), '1.0 MiB') self.assertEqual(fsize(1048576), '1.0 MiB')
self.assertEquals(fsize(1073741823), '1024.0 MiB') self.assertEqual(fsize(1073741823), '1024.0 MiB')
self.assertEquals(fsize(1073741824), '1.0 GiB') self.assertEqual(fsize(1073741824), '1.0 GiB')
self.assertEquals(fsize(112245), '109.6 KiB') self.assertEqual(fsize(112245), '109.6 KiB')
self.assertEquals(fsize(110723441824), '103.1 GiB') self.assertEqual(fsize(110723441824), '103.1 GiB')
self.assertEquals(fsize(1099511627775), '1024.0 GiB') self.assertEqual(fsize(1099511627775), '1024.0 GiB')
self.assertEquals(fsize(1099511627777), '1.0 TiB') self.assertEqual(fsize(1099511627777), '1.0 TiB')
self.assertEquals(fsize(766148267453245), '696.8 TiB') self.assertEqual(fsize(766148267453245), '696.8 TiB')
def test_fpcnt(self): def test_fpcnt(self):
self.failUnless(fpcnt(0.9311) == '93.11%') self.assertTrue(fpcnt(0.9311) == '93.11%')
def test_fspeed(self): def test_fspeed(self):
self.failUnless(fspeed(43134) == '42.1 KiB/s') self.assertTrue(fspeed(43134) == '42.1 KiB/s')
def test_fpeer(self): def test_fpeer(self):
self.failUnless(fpeer(10, 20) == '10 (20)') self.assertTrue(fpeer(10, 20) == '10 (20)')
self.failUnless(fpeer(10, -1) == '10') self.assertTrue(fpeer(10, -1) == '10')
def test_ftime(self): def test_ftime(self):
self.failUnless(ftime(0) == '') self.assertTrue(ftime(0) == '')
self.failUnless(ftime(5) == '5s') self.assertTrue(ftime(5) == '5s')
self.failUnless(ftime(100) == '1m 40s') self.assertTrue(ftime(100) == '1m 40s')
self.failUnless(ftime(3789) == '1h 3m') self.assertTrue(ftime(3789) == '1h 3m')
self.failUnless(ftime(23011) == '6h 23m') self.assertTrue(ftime(23011) == '6h 23m')
self.failUnless(ftime(391187) == '4d 12h') self.assertTrue(ftime(391187) == '4d 12h')
self.failUnless(ftime(604800) == '1w 0d') self.assertTrue(ftime(604800) == '1w 0d')
self.failUnless(ftime(13893086) == '22w 6d') self.assertTrue(ftime(13893086) == '22w 6d')
self.failUnless(ftime(59740269) == '1y 46w') self.assertTrue(ftime(59740269) == '1y 46w')
def test_fdate(self): def test_fdate(self):
self.failUnless(fdate(-1) == '') self.assertTrue(fdate(-1) == '')
def test_is_url(self): def test_is_url(self):
self.failUnless(is_url('http://deluge-torrent.org')) self.assertTrue(is_url('http://deluge-torrent.org'))
self.failIf(is_url('file://test.torrent')) self.assertFalse(is_url('file://test.torrent'))
def test_is_magnet(self): 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): def test_is_infohash(self):
self.failUnless(is_infohash('2dc5d0e71a66fe69649a640d39cb00a259704973')) self.assertTrue(is_infohash('2dc5d0e71a66fe69649a640d39cb00a259704973'))
def test_get_path_size(self): def test_get_path_size(self):
self.failUnless(get_path_size(os.devnull) == 0) self.assertTrue(get_path_size(os.devnull) == 0)
self.failUnless(get_path_size('non-existant.file') == -1) self.assertTrue(get_path_size('non-existant.file') == -1)
def test_is_ip(self): def test_is_ip(self):
self.failUnless(is_ip('192.0.2.0')) self.assertTrue(is_ip('192.0.2.0'))
self.failIf(is_ip('192..0.0')) self.assertFalse(is_ip('192..0.0'))
self.failUnless(is_ip('2001:db8::')) self.assertTrue(is_ip('2001:db8::'))
self.failIf(is_ip('2001:db8:')) self.assertFalse(is_ip('2001:db8:'))
def test_is_ipv4(self): def test_is_ipv4(self):
self.failUnless(is_ipv4('192.0.2.0')) self.assertTrue(is_ipv4('192.0.2.0'))
self.failIf(is_ipv4('192..0.0')) self.assertFalse(is_ipv4('192..0.0'))
def test_is_ipv6(self): def test_is_ipv6(self):
self.failUnless(is_ipv6('2001:db8::')) self.assertTrue(is_ipv6('2001:db8::'))
self.failIf(is_ipv6('2001:db8:')) self.assertFalse(is_ipv6('2001:db8:'))
def test_version_split(self): def test_version_split(self):
self.failUnless(VersionSplit('1.2.2') == VersionSplit('1.2.2')) self.assertTrue(VersionSplit('1.2.2') == VersionSplit('1.2.2'))
self.failUnless(VersionSplit('1.2.1') < VersionSplit('1.2.2')) self.assertTrue(VersionSplit('1.2.1') < VersionSplit('1.2.2'))
self.failUnless(VersionSplit('1.1.9') < VersionSplit('1.2.2')) self.assertTrue(VersionSplit('1.1.9') < VersionSplit('1.2.2'))
self.failUnless(VersionSplit('1.2.2') > VersionSplit('1.2.1')) self.assertTrue(VersionSplit('1.2.2') > VersionSplit('1.2.1'))
self.failUnless(VersionSplit('1.2.2') < VersionSplit('1.2.2-dev')) self.assertTrue(VersionSplit('1.2.2') < VersionSplit('1.2.2-dev'))
self.failUnless(VersionSplit('1.2.2-dev') < VersionSplit('1.3.0-rc2')) self.assertTrue(VersionSplit('1.2.2-dev') < VersionSplit('1.3.0-rc2'))
self.failUnless(VersionSplit('1.2.2') > VersionSplit('1.2.2-rc2')) self.assertTrue(VersionSplit('1.2.2') > VersionSplit('1.2.2-rc2'))
self.failUnless(VersionSplit('1.2.2-rc2-dev') > VersionSplit('1.2.2-rc2')) self.assertTrue(VersionSplit('1.2.2-rc2-dev') > VersionSplit('1.2.2-rc2'))
self.failUnless(VersionSplit('1.2.2-rc3') > VersionSplit('1.2.2-rc2')) self.assertTrue(VersionSplit('1.2.2-rc3') > VersionSplit('1.2.2-rc2'))
self.failUnless(VersionSplit('0.14.9') == VersionSplit('0.14.9')) self.assertTrue(VersionSplit('0.14.9') == VersionSplit('0.14.9'))
self.failUnless(VersionSplit('0.14.9') > VersionSplit('0.14.5')) self.assertTrue(VersionSplit('0.14.9') > VersionSplit('0.14.5'))
self.failUnless(VersionSplit('0.14.10') >= VersionSplit('0.14.9')) self.assertTrue(VersionSplit('0.14.10') >= VersionSplit('0.14.9'))
self.failUnless(VersionSplit('1.4.0') > VersionSplit('1.3.900.dev123')) self.assertTrue(VersionSplit('1.4.0') > VersionSplit('1.3.900.dev123'))
self.failUnless(VersionSplit('1.3.2rc2.dev1') < VersionSplit('1.3.2-rc2')) self.assertTrue(VersionSplit('1.3.2rc2.dev1') < VersionSplit('1.3.2-rc2'))
self.failUnless(VersionSplit('1.3.900.dev888') > VersionSplit('1.3.900.dev123')) self.assertTrue(VersionSplit('1.3.900.dev888') > VersionSplit('1.3.900.dev123'))
self.failUnless(VersionSplit('1.4.0') > VersionSplit('1.4.0.dev123')) self.assertTrue(VersionSplit('1.4.0') > VersionSplit('1.4.0.dev123'))
self.failUnless(VersionSplit('1.4.0.dev1') < VersionSplit('1.4.0')) self.assertTrue(VersionSplit('1.4.0.dev1') < VersionSplit('1.4.0'))
self.failUnless(VersionSplit('1.4.0a1') < VersionSplit('1.4.0')) self.assertTrue(VersionSplit('1.4.0a1') < VersionSplit('1.4.0'))
def test_parse_human_size(self): def test_parse_human_size(self):
from deluge.common import parse_human_size from deluge.common import parse_human_size
@ -126,4 +126,4 @@ class CommonTestCase(unittest.TestCase):
for human_size, byte_size in sizes: for human_size, byte_size in sizes:
parsed = parse_human_size(human_size) 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)

46
deluge/tests/test_component.py
View file

@ -78,8 +78,8 @@ class ComponentTestClass(BaseTestCase):
def test_start_component(self): def test_start_component(self):
def on_start(result, c): def on_start(result, c):
self.assertEquals(c._component_state, 'Started') self.assertEqual(c._component_state, 'Started')
self.assertEquals(c.start_count, 1) self.assertEqual(c.start_count, 1)
c = ComponentTester('test_start_c1') c = ComponentTester('test_start_c1')
d = component.start(['test_start_c1']) d = component.start(['test_start_c1'])
@ -88,16 +88,16 @@ class ComponentTestClass(BaseTestCase):
def test_start_stop_depends(self): def test_start_stop_depends(self):
def on_stop(result, c1, c2): def on_stop(result, c1, c2):
self.assertEquals(c1._component_state, 'Stopped') self.assertEqual(c1._component_state, 'Stopped')
self.assertEquals(c2._component_state, 'Stopped') self.assertEqual(c2._component_state, 'Stopped')
self.assertEquals(c1.stop_count, 1) self.assertEqual(c1.stop_count, 1)
self.assertEquals(c2.stop_count, 1) self.assertEqual(c2.stop_count, 1)
def on_start(result, c1, c2): def on_start(result, c1, c2):
self.assertEquals(c1._component_state, 'Started') self.assertEqual(c1._component_state, 'Started')
self.assertEquals(c2._component_state, 'Started') self.assertEqual(c2._component_state, 'Started')
self.assertEquals(c1.start_count, 1) self.assertEqual(c1.start_count, 1)
self.assertEquals(c2.start_count, 1) self.assertEqual(c2.start_count, 1)
return component.stop(['test_start_depends_c1']).addCallback(on_stop, c1, c2) return component.stop(['test_start_depends_c1']).addCallback(on_stop, c1, c2)
c1 = ComponentTester('test_start_depends_c1') c1 = ComponentTester('test_start_depends_c1')
@ -124,8 +124,8 @@ class ComponentTestClass(BaseTestCase):
def test_start_all(self): def test_start_all(self):
def on_start(*args): def on_start(*args):
for c in args[1:]: for c in args[1:]:
self.assertEquals(c._component_state, 'Started') self.assertEqual(c._component_state, 'Started')
self.assertEquals(c.start_count, 1) self.assertEqual(c.start_count, 1)
ret = self.start_with_depends() ret = self.start_with_depends()
ret[0].addCallback(on_start, *ret[1:]) ret[0].addCallback(on_start, *ret[1:])
@ -141,12 +141,12 @@ class ComponentTestClass(BaseTestCase):
def test_stop_component(self): def test_stop_component(self):
def on_stop(result, c): def on_stop(result, c):
self.assertEquals(c._component_state, 'Stopped') self.assertEqual(c._component_state, 'Stopped')
self.assertFalse(c._component_timer.running) self.assertFalse(c._component_timer.running)
self.assertEquals(c.stop_count, 1) self.assertEqual(c.stop_count, 1)
def on_start(result, c): 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) return component.stop(['test_stop_component_c1']).addCallback(on_stop, c)
c = ComponentTesterUpdate('test_stop_component_c1') c = ComponentTesterUpdate('test_stop_component_c1')
@ -157,12 +157,12 @@ class ComponentTestClass(BaseTestCase):
def test_stop_all(self): def test_stop_all(self):
def on_stop(result, *args): def on_stop(result, *args):
for c in args: for c in args:
self.assertEquals(c._component_state, 'Stopped') self.assertEqual(c._component_state, 'Stopped')
self.assertEquals(c.stop_count, 1) self.assertEqual(c.stop_count, 1)
def on_start(result, *args): def on_start(result, *args):
for c in args: for c in args:
self.assertEquals(c._component_state, 'Started') self.assertEqual(c._component_state, 'Started')
return component.stop().addCallback(on_stop, *args) return component.stop().addCallback(on_stop, *args)
ret = self.start_with_depends() ret = self.start_with_depends()
@ -228,17 +228,19 @@ class ComponentTestClass(BaseTestCase):
self._observer._ignoreErrors(component.ComponentException) self._observer._ignoreErrors(component.ComponentException)
result = yield component.start() result = yield component.start()
self.failUnlessEqual([(result[0][0], result[0][1].value)], self.assertEqual(
[(result[0][0], result[0][1].value)],
[(defer.FAILURE, [(defer.FAILURE,
component.ComponentException('Trying to start component "%s" but it is ' component.ComponentException(
'Trying to start component "%s" but it is '
'not in a stopped state. Current state: %s' % 'not in a stopped state. Current state: %s' %
('test_pause_c1', 'Paused'), ''))]) ('test_pause_c1', 'Paused'), ''))])
def test_shutdown(self): def test_shutdown(self):
def on_shutdown(result, c1): def on_shutdown(result, c1):
self.assertTrue(c1.shutdowned) self.assertTrue(c1.shutdowned)
self.assertEquals(c1._component_state, 'Stopped') self.assertEqual(c1._component_state, 'Stopped')
self.assertEquals(c1.stop_count, 1) self.assertEqual(c1.stop_count, 1)
def on_start(result, c1): def on_start(result, c1):
d = component.shutdown() d = component.shutdown()

36
deluge/tests/test_config.py
View file

@ -26,25 +26,25 @@ class ConfigTestCase(unittest.TestCase):
def test_init(self): def test_init(self):
config = Config('test.conf', defaults=DEFAULTS, config_dir=self.config_dir) 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) config = Config('test.conf', config_dir=self.config_dir)
self.assertEquals({}, config.config) self.assertEqual({}, config.config)
def test_set_get_item(self): def test_set_get_item(self):
config = Config('test.conf', config_dir=self.config_dir) config = Config('test.conf', config_dir=self.config_dir)
config['foo'] = 1 config['foo'] = 1
self.assertEquals(config['foo'], 1) self.assertEqual(config['foo'], 1)
self.assertRaises(ValueError, config.set_item, 'foo', 'bar') self.assertRaises(ValueError, config.set_item, 'foo', 'bar')
config['foo'] = 2 config['foo'] = 2
self.assertEquals(config.get_item('foo'), 2) self.assertEqual(config.get_item('foo'), 2)
config['foo'] = '3' config['foo'] = '3'
self.assertEquals(config.get_item('foo'), 3) self.assertEqual(config.get_item('foo'), 3)
config['unicode'] = 'ВИДЕОФИЛЬМЫ' config['unicode'] = 'ВИДЕОФИЛЬМЫ'
self.assertEquals(config['unicode'], 'ВИДЕОФИЛЬМЫ') self.assertEqual(config['unicode'], 'ВИДЕОФИЛЬМЫ')
config['unicode'] = b'foostring' config['unicode'] = b'foostring'
self.assertFalse(isinstance(config.get_item('unicode'), bytes)) self.assertFalse(isinstance(config.get_item('unicode'), bytes))
@ -59,7 +59,7 @@ class ConfigTestCase(unittest.TestCase):
self.assertIsInstance(config['foo'], type(None)) self.assertIsInstance(config['foo'], type(None))
config['foo'] = 1 config['foo'] = 1
self.assertEquals(config.get('foo'), 1) self.assertEqual(config.get('foo'), 1)
config['foo'] = None config['foo'] = None
self.assertIsNone(config['foo']) self.assertIsNone(config['foo'])
@ -75,18 +75,18 @@ class ConfigTestCase(unittest.TestCase):
def test_get(self): def test_get(self):
config = Config('test.conf', config_dir=self.config_dir) config = Config('test.conf', config_dir=self.config_dir)
config['foo'] = 1 config['foo'] = 1
self.assertEquals(config.get('foo'), 1) self.assertEqual(config.get('foo'), 1)
self.assertEquals(config.get('foobar'), None) self.assertEqual(config.get('foobar'), None)
self.assertEquals(config.get('foobar', 2), 2) self.assertEqual(config.get('foobar', 2), 2)
config['foobar'] = 5 config['foobar'] = 5
self.assertEquals(config.get('foobar', 2), 5) self.assertEqual(config.get('foobar', 2), 5)
def test_load(self): def test_load(self):
def check_config(): def check_config():
config = Config('test.conf', config_dir=self.config_dir) config = Config('test.conf', config_dir=self.config_dir)
self.assertEquals(config['string'], 'foobar') self.assertEqual(config['string'], 'foobar')
self.assertEquals(config['float'], 0.435) self.assertEqual(config['float'], 0.435)
# Test loading an old config from 1.1.x # Test loading an old config from 1.1.x
import pickle import pickle
@ -135,8 +135,8 @@ class ConfigTestCase(unittest.TestCase):
del config del config
config = Config('test.conf', defaults=DEFAULTS, config_dir=self.config_dir) config = Config('test.conf', defaults=DEFAULTS, config_dir=self.config_dir)
self.assertEquals(config['string'], 'baz') self.assertEqual(config['string'], 'baz')
self.assertEquals(config['int'], 2) self.assertEqual(config['int'], 2)
def test_save_timer(self): def test_save_timer(self):
self.clock = task.Clock() self.clock = task.Clock()
@ -154,8 +154,8 @@ class ConfigTestCase(unittest.TestCase):
self.assertTrue(not config._save_timer.active()) self.assertTrue(not config._save_timer.active())
del config del config
config = Config('test.conf', defaults=DEFAULTS, config_dir=self.config_dir) config = Config('test.conf', defaults=DEFAULTS, config_dir=self.config_dir)
self.assertEquals(config['string'], 'baz') self.assertEqual(config['string'], 'baz')
self.assertEquals(config['int'], 2) self.assertEqual(config['int'], 2)
check_config(config) check_config(config)
@ -172,4 +172,4 @@ class ConfigTestCase(unittest.TestCase):
from deluge.config import find_json_objects from deluge.config import find_json_objects
objects = find_json_objects(s) objects = find_json_objects(s)
self.assertEquals(len(objects), 2) self.assertEqual(len(objects), 2)

46
deluge/tests/test_core.py
View file

@ -123,7 +123,7 @@ class CoreTestCase(BaseTestCase):
filedump = base64.encodestring(_file.read()) filedump = base64.encodestring(_file.read())
files_to_add.append((filename, filedump, options)) files_to_add.append((filename, filedump, options))
errors = yield self.core.add_torrent_files(files_to_add) errors = yield self.core.add_torrent_files(files_to_add)
self.assertEquals(len(errors), 0) self.assertEqual(len(errors), 0)
@defer.inlineCallbacks @defer.inlineCallbacks
def test_add_torrent_files_error_duplicate(self): def test_add_torrent_files_error_duplicate(self):
@ -136,7 +136,7 @@ class CoreTestCase(BaseTestCase):
filedump = base64.encodestring(_file.read()) filedump = base64.encodestring(_file.read())
files_to_add.append((filename, filedump, options)) files_to_add.append((filename, filedump, options))
errors = yield self.core.add_torrent_files(files_to_add) 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')) self.assertTrue(str(errors[0]).startswith('Torrent already in session'))
@defer.inlineCallbacks @defer.inlineCallbacks
@ -151,7 +151,7 @@ class CoreTestCase(BaseTestCase):
from deluge.bencode import bdecode, bencode from deluge.bencode import bdecode, bencode
with open(filename) as _file: with open(filename) as _file:
info_hash = sha(bencode(bdecode(_file.read())['info'])).hexdigest() 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): def test_add_torrent_file_invalid_filedump(self):
options = {} options = {}
@ -165,7 +165,7 @@ class CoreTestCase(BaseTestCase):
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00' info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
torrent_id = yield self.core.add_torrent_url(url, options) 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): def test_add_torrent_url_with_cookie(self):
url = 'http://localhost:%d/cookie' % self.listen_port url = 'http://localhost:%d/cookie' % self.listen_port
@ -177,7 +177,7 @@ class CoreTestCase(BaseTestCase):
d.addCallbacks(self.fail, self.assertIsInstance, errbackArgs=(Failure,)) d.addCallbacks(self.fail, self.assertIsInstance, errbackArgs=(Failure,))
d = self.core.add_torrent_url(url, options, headers) 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 return d
@ -187,7 +187,7 @@ class CoreTestCase(BaseTestCase):
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00' info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options) d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash) d.addCallback(self.assertEqual, info_hash)
return d return d
def test_add_torrent_url_with_partial_download(self): def test_add_torrent_url_with_partial_download(self):
@ -196,7 +196,7 @@ class CoreTestCase(BaseTestCase):
info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00' info_hash = '60d5d82328b4547511fdeac9bf4d0112daa0ce00'
d = self.core.add_torrent_url(url, options) d = self.core.add_torrent_url(url, options)
d.addCallback(self.assertEquals, info_hash) d.addCallback(self.assertEqual, info_hash)
return d return d
@defer.inlineCallbacks @defer.inlineCallbacks
@ -205,7 +205,7 @@ class CoreTestCase(BaseTestCase):
uri = deluge.common.create_magnet_uri(info_hash) uri = deluge.common.create_magnet_uri(info_hash)
options = {} options = {}
torrent_id = yield self.core.add_torrent_magnet(uri, 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 @defer.inlineCallbacks
def test_remove_torrent(self): def test_remove_torrent(self):
@ -216,7 +216,7 @@ class CoreTestCase(BaseTestCase):
torrent_id = yield self.core.add_torrent_file(filename, filedump, options) torrent_id = yield self.core.add_torrent_file(filename, filedump, options)
removed = self.core.remove_torrent(torrent_id, True) removed = self.core.remove_torrent(torrent_id, True)
self.assertTrue(removed) 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): def test_remove_torrent_invalid(self):
self.assertRaises(InvalidTorrentError, self.core.remove_torrent, 'torrentidthatdoesntexist', True) self.assertRaises(InvalidTorrentError, self.core.remove_torrent, 'torrentidthatdoesntexist', True)
@ -240,7 +240,7 @@ class CoreTestCase(BaseTestCase):
d.addCallback(test_ret) d.addCallback(test_ret)
def test_session_state(val): 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) d.addCallback(test_session_state)
yield d yield d
@ -258,21 +258,21 @@ class CoreTestCase(BaseTestCase):
def test_get_session_status(self): def test_get_session_status(self):
status = self.core.get_session_status(['upload_rate', 'download_rate']) status = self.core.get_session_status(['upload_rate', 'download_rate'])
self.assertEquals(type(status), dict) self.assertEqual(type(status), dict)
self.assertEquals(status['upload_rate'], 0.0) self.assertEqual(status['upload_rate'], 0.0)
def test_get_session_status_ratio(self): def test_get_session_status_ratio(self):
status = self.core.get_session_status(['write_hit_ratio', 'read_hit_ratio']) status = self.core.get_session_status(['write_hit_ratio', 'read_hit_ratio'])
self.assertEquals(type(status), dict) self.assertEqual(type(status), dict)
self.assertEquals(status['write_hit_ratio'], 0.0) self.assertEqual(status['write_hit_ratio'], 0.0)
self.assertEquals(status['read_hit_ratio'], 0.0) self.assertEqual(status['read_hit_ratio'], 0.0)
def test_get_free_space(self): def test_get_free_space(self):
space = self.core.get_free_space('.') space = self.core.get_free_space('.')
# get_free_space returns long on Python 2 (32-bit). # get_free_space returns long on Python 2 (32-bit).
self.assertTrue(isinstance(space, int if not PY2 else (int, long))) self.assertTrue(isinstance(space, int if not PY2 else (int, long)))
self.assertTrue(space >= 0) 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 @pytest.mark.slow
def test_test_listen_port(self): def test_test_listen_port(self):
@ -297,15 +297,15 @@ class CoreTestCase(BaseTestCase):
} }
for key in pathlist: for key in pathlist:
self.assertEquals(deluge.core.torrent.sanitize_filepath(key, folder=False), pathlist[key]) self.assertEqual(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=True), pathlist[key] + '/')
def test_get_set_config_values(self): def test_get_set_config_values(self):
self.assertEquals(self.core.get_config_values(['abc', 'foo']), {'foo': None, 'abc': None}) self.assertEqual(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_value('foobar'), None)
self.core.set_config({'abc': 'def', 'foo': 10, 'foobar': 'barfoo'}) self.core.set_config({'abc': 'def', 'foo': 10, 'foobar': 'barfoo'})
self.assertEquals(self.core.get_config_values(['foo', 'abc']), {'foo': 10, 'abc': 'def'}) self.assertEqual(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_value('foobar'), 'barfoo')
def test_read_only_config_keys(self): def test_read_only_config_keys(self):
key = 'max_upload_speed' key = 'max_upload_speed'
@ -314,6 +314,6 @@ class CoreTestCase(BaseTestCase):
old_value = self.core.get_config_value(key) old_value = self.core.get_config_value(key)
self.core.set_config({key: old_value + 10}) self.core.set_config({key: old_value + 10})
new_value = self.core.get_config_value(key) 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 self.core.read_only_config_keys = None

12
deluge/tests/test_error.py
View file

@ -22,26 +22,26 @@ class ErrorTestCase(unittest.TestCase):
def test_deluge_error(self): def test_deluge_error(self):
msg = 'Some message' msg = 'Some message'
e = deluge.error.DelugeError(msg) e = deluge.error.DelugeError(msg)
self.assertEquals(str(e), msg) self.assertEqual(str(e), msg)
from twisted.internet.defer import DebugInfo from twisted.internet.defer import DebugInfo
del DebugInfo.__del__ # Hides all errors del DebugInfo.__del__ # Hides all errors
self.assertEquals(e._args, (msg,)) self.assertEqual(e._args, (msg,))
self.assertEquals(e._kwargs, {}) self.assertEqual(e._kwargs, {})
def test_incompatible_client(self): def test_incompatible_client(self):
version = '1.3.6' version = '1.3.6'
e = deluge.error.IncompatibleClient(version) 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) Please upgrade your client to %s' % version)
def test_not_authorized_error(self): def test_not_authorized_error(self):
current_level = 5 current_level = 5
required_level = 10 required_level = 10
e = deluge.error.NotAuthorizedError(current_level, required_level) 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): def test_bad_login_error(self):
message = 'Login failed' message = 'Login failed'
username = 'deluge' username = 'deluge'
e = deluge.error.BadLoginError(message, username) e = deluge.error.BadLoginError(message, username)
self.assertEquals(str(e), message) self.assertEqual(str(e), message)

6
deluge/tests/test_httpdownloader.py
View file

@ -145,10 +145,10 @@ class DownloadFileTestCase(unittest.TestCase):
self.fail(ex) self.fail(ex)
return filename return filename
def failIfContains(self, filename, contents): # NOQA def assertNotContains(self, filename, contents): # NOQA
with open(filename) as _file: with open(filename) as _file:
try: try:
self.failIfEqual(_file.read(), contents) self.assertNotEqual(_file.read(), contents)
except Exception as ex: except Exception as ex:
self.fail(ex) self.fail(ex)
return filename return filename
@ -211,7 +211,7 @@ class DownloadFileTestCase(unittest.TestCase):
def test_download_with_gzip_encoding_disabled(self): def test_download_with_gzip_encoding_disabled(self):
url = self.get_url('gzip?msg=fail') url = self.get_url('gzip?msg=fail')
d = download_file(url, fname('gzip_encoded'), allow_compression=False) d = download_file(url, fname('gzip_encoded'), allow_compression=False)
d.addCallback(self.failIfContains, b'fail') d.addCallback(self.assertNotContains, b'fail')
return d return d
def test_page_redirect_unhandled(self): def test_page_redirect_unhandled(self):

31
deluge/tests/test_json_api.py
View file

@ -63,7 +63,7 @@ class JSONTestCase(JSONBase):
def test_get_remote_methods(self): def test_get_remote_methods(self):
json = JSON() json = JSON()
methods = yield json.get_remote_methods() methods = yield json.get_remote_methods()
self.assertEquals(type(methods), tuple) self.assertEqual(type(methods), tuple)
self.assertTrue(len(methods) > 0) self.assertTrue(len(methods) > 0)
def test_render_fail_disconnected(self): def test_render_fail_disconnected(self):
@ -72,7 +72,7 @@ class JSONTestCase(JSONBase):
request.method = 'POST' request.method = 'POST'
request._disconnected = True request._disconnected = True
# When disconnected, returns empty string # When disconnected, returns empty string
self.assertEquals(json.render(request), '') self.assertEqual(json.render(request), '')
def test_render_fail(self): def test_render_fail(self):
json = JSON() json = JSON()
@ -86,16 +86,16 @@ class JSONTestCase(JSONBase):
def write(response_str): def write(response_str):
request.write_was_called = True request.write_was_called = True
response = json_lib.loads(response_str) response = json_lib.loads(response_str)
self.assertEquals(response['result'], None) self.assertEqual(response['result'], None)
self.assertEquals(response['id'], None) self.assertEqual(response['id'], None)
self.assertEquals(response['error']['message'], 'JSONException: JSON not decodable') self.assertEqual(response['error']['message'], 'JSONException: JSON not decodable')
self.assertEquals(response['error']['code'], 5) self.assertEqual(response['error']['code'], 5)
request.write = write request.write = write
request.write_was_called = False request.write_was_called = False
request._disconnected = False request._disconnected = False
request.getHeader.return_value = 'application/json' 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) self.assertTrue(request.write_was_called)
def test_handle_request_invalid_method(self): def test_handle_request_invalid_method(self):
@ -104,7 +104,7 @@ class JSONTestCase(JSONBase):
json_data = {'method': 'no-existing-module.test', 'id': 0, 'params': []} json_data = {'method': 'no-existing-module.test', 'id': 0, 'params': []}
request.json = json_lib.dumps(json_data) request.json = json_lib.dumps(json_data)
request_id, result, error = json._handle_request(request) 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): def test_handle_request_invalid_json_request(self):
json = JSON() json = JSON()
@ -148,7 +148,7 @@ class JSONCustomUserTestCase(JSONBase):
json_data = {'method': 'core.get_libtorrent_version', 'id': 0, 'params': []} json_data = {'method': 'core.get_libtorrent_version', 'id': 0, 'params': []}
request.json = json_lib.dumps(json_data) request.json = json_lib.dumps(json_data)
request_id, result, error = json._handle_request(request) 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): class RPCRaiseDelugeErrorJSONTestCase(JSONBase):
@ -194,7 +194,7 @@ class RPCRaiseDelugeErrorJSONTestCase(JSONBase):
result.addCallback(self.fail) result.addCallback(self.fail)
def on_error(error): def on_error(error):
self.assertEquals(error.type, DelugeError) self.assertEqual(error.type, DelugeError)
result.addErrback(on_error) result.addErrback(on_error)
yield result yield result
@ -252,12 +252,13 @@ class JSONRequestFailedTestCase(JSONBase, WebServerMockBase):
def write(response_str): def write(response_str):
request.write_was_called = True request.write_was_called = True
response = json_lib.loads(response_str) response = json_lib.loads(response_str)
self.assertEquals(response['result'], None, 'BAD RESULT') self.assertEqual(response['result'], None, 'BAD RESULT')
self.assertEquals(response['id'], 0) self.assertEqual(response['id'], 0)
self.assertEquals(response['error']['message'], self.assertEqual(
response['error']['message'],
'Failure: [Failure instance: Traceback (failure with no frames):' 'Failure: [Failure instance: Traceback (failure with no frames):'
" <class 'deluge.error.DelugeError'>: DelugeERROR\n]") " <class 'deluge.error.DelugeError'>: DelugeERROR\n]")
self.assertEquals(response['error']['code'], 4) self.assertEqual(response['error']['code'], 4)
request.write = write request.write = write
request.write_was_called = False request.write_was_called = False
@ -268,7 +269,7 @@ class JSONRequestFailedTestCase(JSONBase, WebServerMockBase):
d = json._on_json_request(request) d = json._on_json_request(request)
def on_success(arg): def on_success(arg):
self.assertEquals(arg, server.NOT_DONE_YET) self.assertEqual(arg, server.NOT_DONE_YET)
return True return True
d.addCallbacks(on_success, self.fail) d.addCallbacks(on_success, self.fail)
yield d yield d

38
deluge/tests/test_rpcserver.py
View file

@ -59,24 +59,24 @@ class RPCServerTestCase(BaseTestCase):
e = TorrentFolderRenamedEvent(*data) e = TorrentFolderRenamedEvent(*data)
self.rpcserver.emit_event_for_session_id(self.session_id, e) self.rpcserver.emit_event_for_session_id(self.session_id, e)
msg = self.protocol.messages.pop() msg = self.protocol.messages.pop()
self.assertEquals(msg[0], rpcserver.RPC_EVENT, str(msg)) self.assertEqual(msg[0], rpcserver.RPC_EVENT, str(msg))
self.assertEquals(msg[1], 'TorrentFolderRenamedEvent', str(msg)) self.assertEqual(msg[1], 'TorrentFolderRenamedEvent', str(msg))
self.assertEquals(msg[2], data, str(msg)) self.assertEqual(msg[2], data, str(msg))
def test_invalid_client_login(self): def test_invalid_client_login(self):
self.protocol.dispatch(self.request_id, 'daemon.login', [1], {}) self.protocol.dispatch(self.request_id, 'daemon.login', [1], {})
msg = self.protocol.messages.pop() msg = self.protocol.messages.pop()
self.assertEquals(msg[0], rpcserver.RPC_ERROR) self.assertEqual(msg[0], rpcserver.RPC_ERROR)
self.assertEquals(msg[1], self.request_id) self.assertEqual(msg[1], self.request_id)
def test_valid_client_login(self): def test_valid_client_login(self):
self.authmanager = AuthManager() self.authmanager = AuthManager()
auth = get_localhost_auth() auth = get_localhost_auth()
self.protocol.dispatch(self.request_id, 'daemon.login', auth, {'client_version': 'Test'}) self.protocol.dispatch(self.request_id, 'daemon.login', auth, {'client_version': 'Test'})
msg = self.protocol.messages.pop() msg = self.protocol.messages.pop()
self.assertEquals(msg[0], rpcserver.RPC_RESPONSE, str(msg)) self.assertEqual(msg[0], rpcserver.RPC_RESPONSE, str(msg))
self.assertEquals(msg[1], self.request_id, str(msg)) self.assertEqual(msg[1], self.request_id, str(msg))
self.assertEquals(msg[2], rpcserver.AUTH_LEVEL_ADMIN, str(msg)) self.assertEqual(msg[2], rpcserver.AUTH_LEVEL_ADMIN, str(msg))
def test_client_login_error(self): def test_client_login_error(self):
# This test causes error log prints while running the test... # This test causes error log prints while running the test...
@ -85,24 +85,24 @@ class RPCServerTestCase(BaseTestCase):
auth = get_localhost_auth() auth = get_localhost_auth()
self.protocol.dispatch(self.request_id, 'daemon.login', auth, {'client_version': 'Test'}) self.protocol.dispatch(self.request_id, 'daemon.login', auth, {'client_version': 'Test'})
msg = self.protocol.messages.pop() msg = self.protocol.messages.pop()
self.assertEquals(msg[0], rpcserver.RPC_ERROR) self.assertEqual(msg[0], rpcserver.RPC_ERROR)
self.assertEquals(msg[1], self.request_id) self.assertEqual(msg[1], self.request_id)
self.assertEquals(msg[2], 'WrappedException') self.assertEqual(msg[2], 'WrappedException')
self.assertEquals(msg[3][1], 'AttributeError') self.assertEqual(msg[3][1], 'AttributeError')
def test_client_invalid_method_call(self): def test_client_invalid_method_call(self):
self.authmanager = AuthManager() self.authmanager = AuthManager()
auth = get_localhost_auth() auth = get_localhost_auth()
self.protocol.dispatch(self.request_id, 'invalid_function', auth, {}) self.protocol.dispatch(self.request_id, 'invalid_function', auth, {})
msg = self.protocol.messages.pop() msg = self.protocol.messages.pop()
self.assertEquals(msg[0], rpcserver.RPC_ERROR) self.assertEqual(msg[0], rpcserver.RPC_ERROR)
self.assertEquals(msg[1], self.request_id) self.assertEqual(msg[1], self.request_id)
self.assertEquals(msg[2], 'WrappedException') self.assertEqual(msg[2], 'WrappedException')
self.assertEquals(msg[3][1], 'AttributeError') self.assertEqual(msg[3][1], 'AttributeError')
def test_daemon_info(self): def test_daemon_info(self):
self.protocol.dispatch(self.request_id, 'daemon.info', [], {}) self.protocol.dispatch(self.request_id, 'daemon.info', [], {})
msg = self.protocol.messages.pop() msg = self.protocol.messages.pop()
self.assertEquals(msg[0], rpcserver.RPC_RESPONSE, str(msg)) self.assertEqual(msg[0], rpcserver.RPC_RESPONSE, str(msg))
self.assertEquals(msg[1], self.request_id, str(msg)) self.assertEqual(msg[1], self.request_id, str(msg))
self.assertEquals(msg[2], deluge.common.get_version(), str(msg)) self.assertEqual(msg[2], deluge.common.get_version(), str(msg))

12
deluge/tests/test_sessionproxy.py
View file

@ -122,24 +122,24 @@ class SessionProxyTestCase(BaseTestCase):
return component.deregister(self.sp) return component.deregister(self.sp)
def test_startup(self): 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): def test_get_torrent_status_no_change(self):
d = self.sp.get_torrent_status('a', []) 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 return d
def test_get_torrent_status_change_with_cache(self): def test_get_torrent_status_change_with_cache(self):
client.core.torrents['a']['key1'] = 2 client.core.torrents['a']['key1'] = 2
d = self.sp.get_torrent_status('a', ['key1']) d = self.sp.get_torrent_status('a', ['key1'])
d.addCallback(self.assertEquals, {'key1': 1}) d.addCallback(self.assertEqual, {'key1': 1})
return d return d
def test_get_torrent_status_change_without_cache(self): def test_get_torrent_status_change_without_cache(self):
client.core.torrents['a']['key1'] = 2 client.core.torrents['a']['key1'] = 2
self.clock.advance(self.sp.cache_time + 0.1) self.clock.advance(self.sp.cache_time + 0.1)
d = self.sp.get_torrent_status('a', []) 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 return d
def test_get_torrent_status_key_not_updated(self): def test_get_torrent_status_key_not_updated(self):
@ -147,7 +147,7 @@ class SessionProxyTestCase(BaseTestCase):
self.sp.get_torrent_status('a', ['key1']) self.sp.get_torrent_status('a', ['key1'])
client.core.torrents['a']['key2'] = 99 client.core.torrents['a']['key2'] = 99
d = self.sp.get_torrent_status('a', ['key2']) d = self.sp.get_torrent_status('a', ['key2'])
d.addCallback(self.assertEquals, {'key2': 99}) d.addCallback(self.assertEqual, {'key2': 99})
return d return d
def test_get_torrents_status_key_not_updated(self): def test_get_torrents_status_key_not_updated(self):
@ -155,5 +155,5 @@ class SessionProxyTestCase(BaseTestCase):
self.sp.get_torrents_status({'id': ['a']}, ['key1']) self.sp.get_torrents_status({'id': ['a']}, ['key1'])
client.core.torrents['a']['key2'] = 99 client.core.torrents['a']['key2'] = 99
d = self.sp.get_torrents_status({'id': ['a']}, ['key2']) 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 return d

12
deluge/tests/test_torrent.py
View file

@ -57,7 +57,7 @@ class TorrentTestCase(BaseTestCase):
def assert_state(self, torrent, state): def assert_state(self, torrent, state):
torrent.update_state() torrent.update_state()
self.assertEquals(torrent.state, state) self.assertEqual(torrent.state, state)
def get_torrent_atp(self, filename): def get_torrent_atp(self, filename):
filename = common.get_test_data_file(filename) filename = common.get_test_data_file(filename)
@ -86,14 +86,14 @@ class TorrentTestCase(BaseTestCase):
priorities = handle.piece_priorities() priorities = handle.piece_priorities()
# The length of the list of new priorites is the same as the original # 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. # Test the priority of all the pieces against the calculated indexes.
for idx, priority in enumerate(priorities): for idx, priority in enumerate(priorities):
if idx in prioritized_piece_indexes: if idx in prioritized_piece_indexes:
self.assertEquals(priorities[idx], 7) self.assertEqual(priorities[idx], 7)
else: else:
self.assertEquals(priorities[idx], 4) self.assertEqual(priorities[idx], 4)
# self.print_priority_list(priorities) # self.print_priority_list(priorities)
@ -109,7 +109,7 @@ class TorrentTestCase(BaseTestCase):
# Test the priority of the prioritized pieces # Test the priority of the prioritized pieces
for i in priorities: for i in priorities:
self.assertEquals(priorities[i], 4) self.assertEqual(priorities[i], 4)
# self.print_priority_list(priorities) # self.print_priority_list(priorities)
@ -188,7 +188,7 @@ class TorrentTestCase(BaseTestCase):
def assert_resume_data(): def assert_resume_data():
self.assert_state(torrent, 'Error') self.assert_state(torrent, 'Error')
tm_resume_data = lt.bdecode(self.core.torrentmanager.resume_data[torrent.torrent_id]) 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) yield deferLater(reactor, 0.5, assert_resume_data)
return return

66
deluge/tests/test_torrentview.py
View file

@ -80,21 +80,21 @@ class TorrentviewTestCase(BaseTestCase):
def test_torrentview_columns(self): def test_torrentview_columns(self):
self.assertEquals(self.torrentview.column_index, TorrentviewTestCase.default_column_index) self.assertEqual(self.torrentview.column_index, TorrentviewTestCase.default_column_index)
self.assertEquals(self.torrentview.liststore_columns, TorrentviewTestCase.default_liststore_columns) self.assertEqual(self.torrentview.liststore_columns, TorrentviewTestCase.default_liststore_columns)
self.assertEquals(self.torrentview.columns['Download Folder'].column_indices, [29]) self.assertEqual(self.torrentview.columns['Download Folder'].column_indices, [29])
def test_add_column(self): def test_add_column(self):
# Add a text column # Add a text column
test_col = 'Test column' test_col = 'Test column'
self.torrentview.add_text_column(test_col, status_field=['label']) self.torrentview.add_text_column(test_col, status_field=['label'])
self.assertEquals(len(self.torrentview.liststore_columns), self.assertEqual(len(self.torrentview.liststore_columns),
len(TorrentviewTestCase.default_liststore_columns) + 1) len(TorrentviewTestCase.default_liststore_columns) + 1)
self.assertEquals(len(self.torrentview.column_index), self.assertEqual(len(self.torrentview.column_index),
len(TorrentviewTestCase.default_column_index) + 1) len(TorrentviewTestCase.default_column_index) + 1)
self.assertEquals(self.torrentview.column_index[-1], test_col) self.assertEqual(self.torrentview.column_index[-1], test_col)
self.assertEquals(self.torrentview.columns[test_col].column_indices, [32]) self.assertEqual(self.torrentview.columns[test_col].column_indices, [32])
def test_add_columns(self): def test_add_columns(self):
@ -106,17 +106,17 @@ class TorrentviewTestCase(BaseTestCase):
test_col2 = 'Test column2' test_col2 = 'Test column2'
self.torrentview.add_text_column(test_col2, status_field=['label2']) self.torrentview.add_text_column(test_col2, status_field=['label2'])
self.assertEquals(len(self.torrentview.liststore_columns), self.assertEqual(len(self.torrentview.liststore_columns),
len(TorrentviewTestCase.default_liststore_columns) + 2) len(TorrentviewTestCase.default_liststore_columns) + 2)
self.assertEquals(len(self.torrentview.column_index), self.assertEqual(len(self.torrentview.column_index),
len(TorrentviewTestCase.default_column_index) + 2) len(TorrentviewTestCase.default_column_index) + 2)
# test_col # test_col
self.assertEquals(self.torrentview.column_index[-2], test_col) self.assertEqual(self.torrentview.column_index[-2], test_col)
self.assertEquals(self.torrentview.columns[test_col].column_indices, [32]) self.assertEqual(self.torrentview.columns[test_col].column_indices, [32])
# test_col2 # test_col2
self.assertEquals(self.torrentview.column_index[-1], test_col2) self.assertEqual(self.torrentview.column_index[-1], test_col2)
self.assertEquals(self.torrentview.columns[test_col2].column_indices, [33]) self.assertEqual(self.torrentview.columns[test_col2].column_indices, [33])
def test_remove_column(self): def test_remove_column(self):
@ -125,10 +125,10 @@ class TorrentviewTestCase(BaseTestCase):
self.torrentview.add_text_column(test_col, status_field=['label']) self.torrentview.add_text_column(test_col, status_field=['label'])
self.torrentview.remove_column(test_col) self.torrentview.remove_column(test_col)
self.assertEquals(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns)) self.assertEqual(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
self.assertEquals(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index)) self.assertEqual(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
self.assertEquals(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1]) self.assertEqual(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(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])
def test_remove_columns(self): def test_remove_columns(self):
@ -140,36 +140,36 @@ class TorrentviewTestCase(BaseTestCase):
# Remove test_col # Remove test_col
self.torrentview.remove_column(test_col) self.torrentview.remove_column(test_col)
self.assertEquals(len(self.torrentview.liststore_columns), self.assertEqual(len(self.torrentview.liststore_columns),
len(TorrentviewTestCase.default_liststore_columns) + 1) len(TorrentviewTestCase.default_liststore_columns) + 1)
self.assertEquals(len(self.torrentview.column_index), self.assertEqual(len(self.torrentview.column_index),
len(TorrentviewTestCase.default_column_index) + 1) len(TorrentviewTestCase.default_column_index) + 1)
self.assertEquals(self.torrentview.column_index[-1], test_col2) self.assertEqual(self.torrentview.column_index[-1], test_col2)
self.assertEquals(self.torrentview.columns[test_col2].column_indices, [32]) self.assertEqual(self.torrentview.columns[test_col2].column_indices, [32])
# Remove test_col2 # Remove test_col2
self.torrentview.remove_column(test_col2) self.torrentview.remove_column(test_col2)
self.assertEquals(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns)) self.assertEqual(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
self.assertEquals(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index)) self.assertEqual(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
self.assertEquals(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1]) self.assertEqual(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(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])
def test_add_remove_column_multiple_types(self): def test_add_remove_column_multiple_types(self):
# Add a column with multiple column types # Add a column with multiple column types
test_col3 = 'Test column3' test_col3 = 'Test column3'
self.torrentview.add_progress_column(test_col3, status_field=['progress', 'label3'], col_types=[float, str]) self.torrentview.add_progress_column(test_col3, status_field=['progress', 'label3'], col_types=[float, str])
self.assertEquals(len(self.torrentview.liststore_columns), self.assertEqual(len(self.torrentview.liststore_columns),
len(TorrentviewTestCase.default_liststore_columns) + 2) len(TorrentviewTestCase.default_liststore_columns) + 2)
self.assertEquals(len(self.torrentview.column_index), self.assertEqual(len(self.torrentview.column_index),
len(TorrentviewTestCase.default_column_index) + 1) len(TorrentviewTestCase.default_column_index) + 1)
self.assertEquals(self.torrentview.column_index[-1], test_col3) self.assertEqual(self.torrentview.column_index[-1], test_col3)
self.assertEquals(self.torrentview.columns[test_col3].column_indices, [32, 33]) self.assertEqual(self.torrentview.columns[test_col3].column_indices, [32, 33])
# Remove multiple column-types column # Remove multiple column-types column
self.torrentview.remove_column(test_col3) self.torrentview.remove_column(test_col3)
self.assertEquals(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns)) self.assertEqual(len(self.torrentview.liststore_columns), len(TorrentviewTestCase.default_liststore_columns))
self.assertEquals(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index)) self.assertEqual(len(self.torrentview.column_index), len(TorrentviewTestCase.default_column_index))
self.assertEquals(self.torrentview.column_index[-1], TorrentviewTestCase.default_column_index[-1]) self.assertEqual(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(self.torrentview.columns[TorrentviewTestCase.default_column_index[-1]].column_indices, [31])

8
deluge/tests/test_tracker_icons.py
View file

@ -35,7 +35,7 @@ class TrackerIconsTestCase(BaseTestCase):
icon = TrackerIcon(common.get_test_data_file('deluge.png')) icon = TrackerIcon(common.get_test_data_file('deluge.png'))
d = self.icons.fetch('deluge-torrent.org') d = self.icons.fetch('deluge-torrent.org')
d.addCallback(self.assertNotIdentical, None) d.addCallback(self.assertNotIdentical, None)
d.addCallback(self.assertEquals, icon) d.addCallback(self.assertEqual, icon)
return d return d
def test_get_google_ico(self): def test_get_google_ico(self):
@ -44,7 +44,7 @@ class TrackerIconsTestCase(BaseTestCase):
icon = TrackerIcon(common.get_test_data_file('google.ico')) icon = TrackerIcon(common.get_test_data_file('google.ico'))
d = self.icons.fetch('www.google.com') d = self.icons.fetch('www.google.com')
d.addCallback(self.assertNotIdentical, None) d.addCallback(self.assertNotIdentical, None)
d.addCallback(self.assertEquals, icon) d.addCallback(self.assertEqual, icon)
return d return d
def test_get_google_ico_with_redirect(self): def test_get_google_ico_with_redirect(self):
@ -52,7 +52,7 @@ class TrackerIconsTestCase(BaseTestCase):
icon = TrackerIcon(common.get_test_data_file('google.ico')) icon = TrackerIcon(common.get_test_data_file('google.ico'))
d = self.icons.fetch('google.com') d = self.icons.fetch('google.com')
d.addCallback(self.assertNotIdentical, None) d.addCallback(self.assertNotIdentical, None)
d.addCallback(self.assertEquals, icon) d.addCallback(self.assertEqual, icon)
return d return d
def test_get_ubuntu_ico(self): def test_get_ubuntu_ico(self):
@ -60,7 +60,7 @@ class TrackerIconsTestCase(BaseTestCase):
icon = TrackerIcon(common.get_test_data_file('ubuntu.png')) icon = TrackerIcon(common.get_test_data_file('ubuntu.png'))
d = self.icons.fetch('www.ubuntu.com') d = self.icons.fetch('www.ubuntu.com')
d.addCallback(self.assertNotIdentical, None) d.addCallback(self.assertNotIdentical, None)
d.addCallback(self.assertEquals, icon) d.addCallback(self.assertEqual, icon)
return d return d
def test_get_empty_string_tracker(self): def test_get_empty_string_tracker(self):

42
deluge/tests/test_transfer.py
View file

@ -141,7 +141,7 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
# Get the data as sent by DelugeTransferProtocol # Get the data as sent by DelugeTransferProtocol
messages = self.transfer.get_messages_out_joined() messages = self.transfer.get_messages_out_joined()
base64_encoded = base64.b64encode(messages) 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): def test_receive_one_message(self):
""" """
@ -152,7 +152,7 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
self.transfer.dataReceived(base64.b64decode(self.msg1_expected_compressed_base64)) self.transfer.dataReceived(base64.b64decode(self.msg1_expected_compressed_base64))
# Get the data as sent by DelugeTransferProtocol # Get the data as sent by DelugeTransferProtocol
messages = self.transfer.get_messages_in().pop(0) 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): def test_receive_old_message(self):
""" """
@ -160,9 +160,9 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
""" """
self.transfer.dataReceived(rencode.dumps(self.msg1)) self.transfer.dataReceived(rencode.dumps(self.msg1))
self.assertEquals(len(self.transfer.get_messages_in()), 0) self.assertEqual(len(self.transfer.get_messages_in()), 0)
self.assertEquals(self.transfer._message_length, 0) self.assertEqual(self.transfer._message_length, 0)
self.assertEquals(len(self.transfer._buffer), 0) self.assertEqual(len(self.transfer._buffer), 0)
def test_receive_two_concatenated_messages(self): def test_receive_two_concatenated_messages(self):
""" """
@ -176,9 +176,9 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
# Get the data as sent by DelugeTransferProtocol # Get the data as sent by DelugeTransferProtocol
message1 = self.transfer.get_messages_in().pop(0) 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) 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): def test_receive_three_messages_in_parts(self):
""" """
@ -209,15 +209,15 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
else: else:
expected_msgs_received_count = 0 expected_msgs_received_count = 0
# Verify that the expected number of complete messages has arrived # 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 # Get the data as received by DelugeTransferProtocol
message1 = self.transfer.get_messages_in().pop(0) 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) 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) 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: # Remove underscore to enable test, or run the test directly:
# tests $ trial test_transfer.DelugeTransferProtocolTestCase._test_rencode_fail_protocol # tests $ trial test_transfer.DelugeTransferProtocolTestCase._test_rencode_fail_protocol
@ -265,11 +265,11 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
# Get the data as received by DelugeTransferProtocol # Get the data as received by DelugeTransferProtocol
message1 = self.transfer.get_messages_in().pop(0) 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) 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) 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): def test_receive_middle_of_header(self):
""" """
@ -291,19 +291,19 @@ class DelugeTransferProtocolTestCase(unittest.TestCase):
self.transfer.dataReceived(two_concatenated[:first_len + 2]) self.transfer.dataReceived(two_concatenated[:first_len + 2])
# Should be 1 message in the list # 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 # Send the rest
self.transfer.dataReceived(two_concatenated[first_len + 2:]) self.transfer.dataReceived(two_concatenated[first_len + 2:])
# Should be 2 messages in the list # 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 # Get the data as sent by DelugeTransferProtocol
message1 = self.transfer.get_messages_in().pop(0) 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) 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 # Needs file containing big data structure e.g. like thetorrent list as it is transfered by the daemon
# def test_simulate_big_transfer(self): # 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): # for d in self.receive_parts_helper(compressed_data, packet_size):
# bytes_recv = self.transfer.get_bytes_recv() # bytes_recv = self.transfer.get_bytes_recv()
# if bytes_recv < len(compressed_data): # 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: # 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 # Get the data as received by DelugeTransferProtocol
# transfered_message = self.transfer.get_messages_in().pop(0) # transfered_message = self.transfer.get_messages_in().pop(0)
# Test that the data structures are equal # 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) # self.assertTrue(transfered_message == message_to_send)
# #
# f.close() # f.close()

34
deluge/tests/test_web_api.py
View file

@ -38,7 +38,7 @@ class WebAPITestCase(WebServerTestBase):
d = self.deluge_web.web_api.connect(self.host_id) d = self.deluge_web.web_api.connect(self.host_id)
def on_connect(result): def on_connect(result):
self.assertEquals(type(result), tuple) self.assertEqual(type(result), tuple)
self.assertTrue(len(result) > 0) self.assertTrue(len(result) > 0)
self.addCleanup(client.disconnect) self.addCleanup(client.disconnect)
return result return result
@ -62,7 +62,7 @@ class WebAPITestCase(WebServerTestBase):
def test_get_config(self): def test_get_config(self):
config = self.deluge_web.web_api.get_config() 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): def test_set_config(self):
config = self.deluge_web.web_api.get_config() config = self.deluge_web.web_api.get_config()
@ -87,35 +87,35 @@ class WebAPITestCase(WebServerTestBase):
host[3] = 'Online' host[3] = 'Online'
host[4] = '2.0.0.dev562' host[4] = '2.0.0.dev562'
status = yield self.deluge_web.web_api.get_host_status(self.host_id) 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): def test_get_host(self):
self.assertFalse(self.deluge_web.web_api._get_host('invalid_id')) self.assertFalse(self.deluge_web.web_api._get_host('invalid_id'))
conn = self.deluge_web.web_api.host_list['hosts'][0] 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): def test_add_host(self):
conn = [None, '', 0, '', ''] conn = [None, '', 0, '', '']
self.assertFalse(self.deluge_web.web_api._get_host(conn[0])) self.assertFalse(self.deluge_web.web_api._get_host(conn[0]))
# Add valid host # Add valid host
ret = self.deluge_web.web_api.add_host(conn[1], conn[2], conn[3], conn[4]) 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] 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 # Add already existing host
ret = self.deluge_web.web_api.add_host(conn[1], conn[2], conn[3], conn[4]) 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 # Add invalid port
conn[2] = 'bad port' conn[2] = 'bad port'
ret = self.deluge_web.web_api.add_host(conn[1], conn[2], conn[3], conn[4]) 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): def test_remove_host(self):
conn = ['connection_id', '', 0, '', ''] conn = ['connection_id', '', 0, '', '']
self.deluge_web.web_api.host_list['hosts'].append(conn) 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 # Remove valid host
self.assertTrue(self.deluge_web.web_api.remove_host(conn[0])) self.assertTrue(self.deluge_web.web_api.remove_host(conn[0]))
self.assertFalse(self.deluge_web.web_api._get_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): def test_get_torrent_info(self):
filename = common.get_test_data_file('test.torrent') filename = common.get_test_data_file('test.torrent')
ret = self.deluge_web.web_api.get_torrent_info(filename) ret = self.deluge_web.web_api.get_torrent_info(filename)
self.assertEquals(ret['name'], 'azcvsupdater_2.6.2.jar') self.assertEqual(ret['name'], 'azcvsupdater_2.6.2.jar')
self.assertEquals(ret['info_hash'], 'ab570cdd5a17ea1b61e970bb72047de141bce173') self.assertEqual(ret['info_hash'], 'ab570cdd5a17ea1b61e970bb72047de141bce173')
self.assertTrue('files_tree' in ret) self.assertTrue('files_tree' in ret)
def test_get_magnet_info(self): def test_get_magnet_info(self):
ret = self.deluge_web.web_api.get_magnet_info('magnet:?xt=urn:btih:SU5225URMTUEQLDXQWRB2EQWN6KLTYKN') ret = self.deluge_web.web_api.get_magnet_info('magnet:?xt=urn:btih:SU5225URMTUEQLDXQWRB2EQWN6KLTYKN')
self.assertEquals(ret['name'], '953bad769164e8482c7785a21d12166f94b9e14d') self.assertEqual(ret['name'], '953bad769164e8482c7785a21d12166f94b9e14d')
self.assertEquals(ret['info_hash'], '953bad769164e8482c7785a21d12166f94b9e14d') self.assertEqual(ret['info_hash'], '953bad769164e8482c7785a21d12166f94b9e14d')
self.assertTrue('files_tree' in ret) self.assertTrue('files_tree' in ret)
@defer.inlineCallbacks @defer.inlineCallbacks
@ -142,9 +142,11 @@ class WebAPITestCase(WebServerTestBase):
torrents = [{'path': filename, 'options': {'download_location': '/home/deluge/'}}] torrents = [{'path': filename, 'options': {'download_location': '/home/deluge/'}}]
yield self.deluge_web.web_api.add_torrents(torrents) yield self.deluge_web.web_api.add_torrents(torrents)
ret = yield self.deluge_web.web_api.get_torrent_files('ab570cdd5a17ea1b61e970bb72047de141bce173') ret = yield self.deluge_web.web_api.get_torrent_files('ab570cdd5a17ea1b61e970bb72047de141bce173')
self.assertEquals(ret['type'], 'dir') self.assertEqual(ret['type'], 'dir')
self.assertEquals(ret['contents'], {'azcvsupdater_2.6.2.jar': self.assertEqual(
{'priority': 4, 'index': 0, 'offset': 0, 'progress': 0.0, 'path': 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}}) 'azcvsupdater_2.6.2.jar', 'type': 'file', 'size': 307949}})
@defer.inlineCallbacks @defer.inlineCallbacks