From 73ea123f1a401e0bddf381bdf96d2e498b688332 Mon Sep 17 00:00:00 2001 From: Calum Lind Date: Sun, 19 Mar 2017 22:14:40 +0000 Subject: [PATCH] [#2966] [Tests] Rename deprecated method aliases --- deluge/tests/test_alertmanager.py | 4 +- deluge/tests/test_authmanager.py | 2 +- deluge/tests/test_client.py | 6 +- deluge/tests/test_common.py | 120 ++++++++++++++-------------- deluge/tests/test_component.py | 52 ++++++------ deluge/tests/test_config.py | 36 ++++----- deluge/tests/test_core.py | 46 +++++------ deluge/tests/test_error.py | 12 +-- deluge/tests/test_httpdownloader.py | 6 +- deluge/tests/test_json_api.py | 35 ++++---- deluge/tests/test_rpcserver.py | 38 ++++----- deluge/tests/test_sessionproxy.py | 12 +-- deluge/tests/test_torrent.py | 12 +-- deluge/tests/test_torrentview.py | 82 +++++++++---------- deluge/tests/test_tracker_icons.py | 8 +- deluge/tests/test_transfer.py | 42 +++++----- deluge/tests/test_web_api.py | 36 +++++---- 17 files changed, 277 insertions(+), 272 deletions(-) diff --git a/deluge/tests/test_alertmanager.py b/deluge/tests/test_alertmanager.py index 16146b213..bca157c1d 100644 --- a/deluge/tests/test_alertmanager.py +++ b/deluge/tests/test_alertmanager.py @@ -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'], []) diff --git a/deluge/tests/test_authmanager.py b/deluge/tests/test_authmanager.py index 70f231082..d8b502a89 100644 --- a/deluge/tests/test_authmanager.py +++ b/deluge/tests/test_authmanager.py @@ -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 ) diff --git a/deluge/tests/test_client.py b/deluge/tests/test_client.py index d2c36c7e3..839f46fd1 100644 --- a/deluge/tests/test_client.py +++ b/deluge/tests/test_client.py @@ -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 diff --git a/deluge/tests/test_common.py b/deluge/tests/test_common.py index ba5fbf4bb..12e6b8883 100644 --- a/deluge/tests/test_common.py +++ b/deluge/tests/test_common.py @@ -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) diff --git a/deluge/tests/test_component.py b/deluge/tests/test_component.py index 10cc3b9b4..de44fc10d 100644 --- a/deluge/tests/test_component.py +++ b/deluge/tests/test_component.py @@ -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() diff --git a/deluge/tests/test_config.py b/deluge/tests/test_config.py index 6445b305a..6b6a38506 100644 --- a/deluge/tests/test_config.py +++ b/deluge/tests/test_config.py @@ -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) diff --git a/deluge/tests/test_core.py b/deluge/tests/test_core.py index edb60063f..135e2462c 100644 --- a/deluge/tests/test_core.py +++ b/deluge/tests/test_core.py @@ -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 diff --git a/deluge/tests/test_error.py b/deluge/tests/test_error.py index 6bbfa72cd..238337f35 100644 --- a/deluge/tests/test_error.py +++ b/deluge/tests/test_error.py @@ -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) diff --git a/deluge/tests/test_httpdownloader.py b/deluge/tests/test_httpdownloader.py index a5cc3d27e..08bbd295a 100644 --- a/deluge/tests/test_httpdownloader.py +++ b/deluge/tests/test_httpdownloader.py @@ -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): diff --git a/deluge/tests/test_json_api.py b/deluge/tests/test_json_api.py index b04175048..28c12683e 100644 --- a/deluge/tests/test_json_api.py +++ b/deluge/tests/test_json_api.py @@ -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):' - " : 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):' + " : 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 diff --git a/deluge/tests/test_rpcserver.py b/deluge/tests/test_rpcserver.py index 2afc77318..ab8239bc1 100644 --- a/deluge/tests/test_rpcserver.py +++ b/deluge/tests/test_rpcserver.py @@ -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)) diff --git a/deluge/tests/test_sessionproxy.py b/deluge/tests/test_sessionproxy.py index 9b3b128c5..5f2ea4f84 100644 --- a/deluge/tests/test_sessionproxy.py +++ b/deluge/tests/test_sessionproxy.py @@ -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 diff --git a/deluge/tests/test_torrent.py b/deluge/tests/test_torrent.py index 680eddd52..2f57e45dd 100644 --- a/deluge/tests/test_torrent.py +++ b/deluge/tests/test_torrent.py @@ -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 diff --git a/deluge/tests/test_torrentview.py b/deluge/tests/test_torrentview.py index d6622c978..8024546a7 100644 --- a/deluge/tests/test_torrentview.py +++ b/deluge/tests/test_torrentview.py @@ -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]) diff --git a/deluge/tests/test_tracker_icons.py b/deluge/tests/test_tracker_icons.py index 1817c7ce9..ab0f00b35 100644 --- a/deluge/tests/test_tracker_icons.py +++ b/deluge/tests/test_tracker_icons.py @@ -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): diff --git a/deluge/tests/test_transfer.py b/deluge/tests/test_transfer.py index c4d1293ed..0ac13b303 100644 --- a/deluge/tests/test_transfer.py +++ b/deluge/tests/test_transfer.py @@ -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() diff --git a/deluge/tests/test_web_api.py b/deluge/tests/test_web_api.py index 7ab6e7f17..ecec2991a 100644 --- a/deluge/tests/test_web_api.py +++ b/deluge/tests/test_web_api.py @@ -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):