def test_connect_peer_port(self): """Test to ensure port is int for libtorrent""" atp = self.get_torrent_atp('test_torrent.file.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) self.assertFalse(self.torrent.connect_peer('127.0.0.1', 'text')) self.assertTrue(self.torrent.connect_peer('127.0.0.1', '1234'))
def run_test_set_prioritize_first_last(self, torrent_file, prioritized_piece_indexes): atp = self.get_torrent_atp(torrent_file) handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) priorities_original = handle.piece_priorities() prioritized_pieces, new_priorites = self.torrent.set_prioritize_first_last( True) priorities = handle.piece_priorities() non_prioritized_pieces = list(range(len(priorities))) # The prioritized indexes are the same as we expect self.assertEquals(prioritized_pieces, prioritized_piece_indexes) # Test the priority of the prioritized pieces for first, last in prioritized_pieces: for i in range(first, last): if i in non_prioritized_pieces: non_prioritized_pieces.remove(i) self.assertEquals(priorities[i], 7) # Test the priority of all the non-prioritized pieces for i in non_prioritized_pieces: self.assertEquals(priorities[i], 1) # The length of the list of new priorites is the same as the original self.assertEquals(len(priorities_original), len(new_priorites))
def test_rename_unicode(self): """Test renaming file/folders with unicode filenames.""" atp = self.get_torrent_atp('unicode_filenames.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) # Ignore TorrentManager method call TorrentManager.save_resume_data = mock.MagicMock result = self.torrent.rename_folder('unicode_filenames', 'Горбачёв') self.assertIsInstance(result, defer.DeferredList) result = self.torrent.rename_files([[0, 'new_рбачёв']]) self.assertIsNone(result)
def test_set_prioritize_first_last_pieces_false(self): atp = self.get_torrent_atp('dir_with_6_files.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) # First set some pieces prioritized self.torrent.set_prioritize_first_last_pieces(True) # Reset pirorities self.torrent.set_prioritize_first_last_pieces(False) priorities = handle.piece_priorities() # Test the priority of the prioritized pieces for i in priorities: self.assertEqual(priorities[i], 4)
def test_get_eta_downloading(self): atp = self.get_torrent_atp('test_torrent.file.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) self.assertEqual(self.torrent.get_eta(), 0) self.torrent.status = mock.MagicMock() self.torrent.status.download_payload_rate = 50 self.torrent.status.total_wanted = 10000 self.torrent.status.total_wanted_done = 5000 result = self.torrent.get_eta() self.assertEqual(result, 100) self.assertIsInstance(result, int)
def run_test_set_prioritize_first_last(self, torrent_file, prioritized_piece_indexes): atp = self.get_torrent_atp(torrent_file) handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) priorities_original = handle.piece_priorities() prioritized_pieces, new_priorites = self.torrent.set_prioritize_first_last(True) priorities = handle.piece_priorities() non_prioritized_pieces = list(range(len(priorities))) # The prioritized indexes are the same as we expect self.assertEquals(prioritized_pieces, prioritized_piece_indexes) # Test the priority of the prioritized pieces for first, last in prioritized_pieces: for i in range(first, last): if i in non_prioritized_pieces: non_prioritized_pieces.remove(i) self.assertEquals(priorities[i], 7) # Test the priority of all the non-prioritized pieces for i in non_prioritized_pieces: self.assertEquals(priorities[i], 1) # The length of the list of new priorites is the same as the original self.assertEquals(len(priorities_original), len(new_priorites))
def run_test_set_prioritize_first_last_pieces(self, torrent_file, prioritized_piece_indexes): atp = self.get_torrent_atp(torrent_file) handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) priorities_original = handle.piece_priorities() self.torrent.set_prioritize_first_last_pieces(True) priorities = handle.piece_priorities() # The length of the list of new priorites is the same as the original 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.assertEqual(priorities[idx], 7) else: self.assertEqual(priorities[idx], 4)
def test_get_eta_seeding(self): atp = self.get_torrent_atp('test_torrent.file.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) self.assertEqual(self.torrent.get_eta(), 0) self.torrent.status = mock.MagicMock() self.torrent.status.upload_payload_rate = 5000 self.torrent.status.download_payload_rate = 0 self.torrent.status.all_time_download = 10000 self.torrent.status.all_time_upload = 500 self.torrent.is_finished = True self.torrent.options = {'stop_at_ratio': False} # Test finished and uploading but no stop_at_ratio set. self.assertEqual(self.torrent.get_eta(), 0) self.torrent.options = {'stop_at_ratio': True, 'stop_ratio': 1.5} result = self.torrent.get_eta() self.assertEqual(result, 2) self.assertIsInstance(result, int)
def test_set_file_priorities(self): atp = self.get_torrent_atp('dir_with_6_files.torrent') handle = self.session.add_torrent(atp) torrent = Torrent(handle, {}) result = torrent.get_file_priorities() self.assertTrue(all(x == 4 for x in result)) new_priorities = [3, 1, 2, 0, 5, 6, 7] torrent.set_file_priorities(new_priorities) self.assertEqual(torrent.get_file_priorities(), new_priorities) # Test with handle.piece_priorities as handle.file_priorities async # updates and will return old value. Also need to remove a priority # value as one file is much smaller than piece size so doesn't show. piece_prio = handle.piece_priorities() result = all(p in piece_prio for p in [3, 2, 0, 5, 6, 7]) self.assertTrue(result)
class TorrentTestCase(BaseTestCase): def setup_config(self): config_dir = common.set_tmp_config_dir() core_config = deluge.config.Config('core.conf', defaults=deluge.core.preferencesmanager.DEFAULT_PREFS, config_dir=config_dir) core_config.save() def set_up(self): self.setup_config() RPCServer(listen=False) self.core = Core() self.session = lt.session() self.torrent = None return component.start() def tear_down(self): return component.shutdown() def print_priority_list(self, priorities): tmp = '' for i, p in enumerate(priorities): if i % 100 == 0: print(tmp) tmp = '' tmp += '%s' % p print(tmp) def assert_state(self, torrent, state): torrent.update_state() self.assertEqual(torrent.state, state) def get_torrent_atp(self, filename): filename = common.get_test_data_file(filename) with open(filename, 'rb') as _file: info = lt.torrent_info(lt.bdecode(_file.read())) atp = {'ti': info} atp['save_path'] = os.getcwd() atp['storage_mode'] = lt.storage_mode_t.storage_mode_sparse atp['add_paused'] = False atp['auto_managed'] = True atp['duplicate_is_error'] = True return atp def test_set_prioritize_first_last_pieces(self): piece_indexes = [0, 1, 50, 51, 52, 110, 111, 112, 113, 200, 201, 202, 212, 213, 214, 215, 216, 217, 457, 458, 459, 460, 461, 462] self.run_test_set_prioritize_first_last_pieces('dir_with_6_files.torrent', piece_indexes) def run_test_set_prioritize_first_last_pieces(self, torrent_file, prioritized_piece_indexes): atp = self.get_torrent_atp(torrent_file) handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) priorities_original = handle.piece_priorities() self.torrent.set_prioritize_first_last_pieces(True) priorities = handle.piece_priorities() # The length of the list of new priorites is the same as the original 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.assertEqual(priorities[idx], 7) else: self.assertEqual(priorities[idx], 4) # self.print_priority_list(priorities) def test_set_prioritize_first_last_pieces_false(self): atp = self.get_torrent_atp('dir_with_6_files.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) # First set some pieces prioritized self.torrent.set_prioritize_first_last_pieces(True) # Reset pirorities self.torrent.set_prioritize_first_last_pieces(False) priorities = handle.piece_priorities() # Test the priority of the prioritized pieces for i in priorities: self.assertEqual(priorities[i], 4) # self.print_priority_list(priorities) @defer.inlineCallbacks def test_torrent_error_data_missing(self): options = {'seed_mode': True} filename = common.get_test_data_file('test_torrent.file.torrent') with open(filename) as _file: filedump = base64.encodestring(_file.read()) torrent_id = yield self.core.add_torrent_file(filename, filedump, options) torrent = self.core.torrentmanager.torrents[torrent_id] self.assert_state(torrent, 'Seeding') # Force an error by reading (non-existant) piece from disk torrent.handle.read_piece(0) time.sleep(0.2) # Delay to wait for alert from lt self.assert_state(torrent, 'Error') @defer.inlineCallbacks def test_torrent_error_resume_original_state(self): options = {'seed_mode': True, 'add_paused': True} filename = common.get_test_data_file('test_torrent.file.torrent') with open(filename) as _file: filedump = base64.encodestring(_file.read()) torrent_id = yield self.core.add_torrent_file(filename, filedump, options) torrent = self.core.torrentmanager.torrents[torrent_id] orig_state = 'Paused' self.assert_state(torrent, orig_state) # Force an error by reading (non-existant) piece from disk torrent.handle.read_piece(0) time.sleep(0.2) # Delay to wait for alert from lt self.assert_state(torrent, 'Error') # Clear error and verify returned to original state torrent.force_recheck() yield deferLater(reactor, 0.1, self.assert_state, torrent, orig_state) return @defer.inlineCallbacks def test_torrent_error_resume_data_unaltered(self): resume_data = {'active_time': 13399, 'num_incomplete': 16777215, 'announce_to_lsd': 1, 'seed_mode': 0, 'pieces': '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01', 'paused': 0, 'seeding_time': 13399, 'last_scrape': 13399, 'info-hash': '-\xc5\xd0\xe7\x1af\xfeid\x9ad\r9\xcb\x00\xa2YpIs', 'max_uploads': 16777215, 'max_connections': 16777215, 'num_downloaders': 16777215, 'total_downloaded': 0, 'file-format': 'libtorrent resume file', 'peers6': '', 'added_time': 1411826665, 'banned_peers6': '', 'file_priority': [1], 'last_seen_complete': 0, 'total_uploaded': 0, 'piece_priority': '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01', 'file-version': 1, 'announce_to_dht': 1, 'auto_managed': 1, 'upload_rate_limit': 0, 'completed_time': 1411826665, 'allocation': 'sparse', 'blocks per piece': 2, 'download_rate_limit': 0, 'libtorrent-version': '0.16.17.0', 'banned_peers': '', 'num_seeds': 16777215, 'sequential_download': 0, 'announce_to_trackers': 1, 'peers': '\n\x00\x02\x0f=\xc6SC\x17]\xd8}\x7f\x00\x00\x01=\xc6', 'finished_time': 13399, 'last_upload': 13399, 'trackers': [[]], 'super_seeding': 0, 'file sizes': [[512000, 1411826586]], 'last_download': 13399} torrent_state = TorrentState( torrent_id='2dc5d0e71a66fe69649a640d39cb00a259704973', filename='test_torrent.file.torrent', name='', save_path='/home/ubuntu/Downloads', file_priorities=[1], is_finished=True, ) filename = common.get_test_data_file('test_torrent.file.torrent') with open(filename) as _file: filedump = _file.read() resume_data = utf8_encode_structure(resume_data) torrent_id = yield self.core.torrentmanager.add(state=torrent_state, filedump=filedump, resume_data=lt.bencode(resume_data)) torrent = self.core.torrentmanager.torrents[torrent_id] def assert_resume_data(): self.assert_state(torrent, 'Error') tm_resume_data = lt.bdecode(self.core.torrentmanager.resume_data[torrent.torrent_id]) self.assertEqual(tm_resume_data, resume_data) yield deferLater(reactor, 0.5, assert_resume_data) return
class TorrentTestCase(unittest.TestCase): def setup_config(self): global config_setup config_setup = True config_dir = common.set_tmp_config_dir() core_config = deluge.config.Config( "core.conf", defaults=deluge.core.preferencesmanager.DEFAULT_PREFS, config_dir=config_dir) core_config.save() def setUp(self): self.setup_config() global rpcserver global core rpcserver = RPCServer(listen=False) core = Core() self.session = lt.session() self.torrent = None return component.start() def tearDown(self): if self.torrent: self.torrent.prev_status_cleanup_loop.stop() def on_shutdown(result): component._ComponentRegistry.components = {} return component.shutdown().addCallback(on_shutdown) def print_priority_list(self, priorities): tmp = '' for i, p in enumerate(priorities): if i % 100 == 0: print tmp tmp = '' tmp += "%s" % p print tmp def get_torrent_atp(self, filename): filename = os.path.join(os.path.dirname(__file__), filename) e = lt.bdecode(open(filename, 'rb').read()) info = lt.torrent_info(e) atp = {"ti": info} atp["save_path"] = os.getcwd() atp["storage_mode"] = lt.storage_mode_t.storage_mode_sparse atp["add_paused"] = False atp["auto_managed"] = True atp["duplicate_is_error"] = True return atp def test_set_prioritize_first_last(self): piece_indexes = [(0, 1), (0, 1), (0, 1), (0, 1), (0, 2), (50, 52), (51, 53), (110, 112), (111, 114), (200, 203), (202, 203), (212, 213), (212, 218), (457, 463)] self.run_test_set_prioritize_first_last("dir_with_6_files.torrent", piece_indexes) def run_test_set_prioritize_first_last(self, torrent_file, prioritized_piece_indexes): atp = self.get_torrent_atp(torrent_file) handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) priorities_original = handle.piece_priorities() prioritized_pieces, new_priorites = self.torrent.set_prioritize_first_last( True) priorities = handle.piece_priorities() non_prioritized_pieces = list(range(len(priorities))) # The prioritized indexes are the same as we expect self.assertEquals(prioritized_pieces, prioritized_piece_indexes) # Test the priority of the prioritized pieces for first, last in prioritized_pieces: for i in range(first, last): if i in non_prioritized_pieces: non_prioritized_pieces.remove(i) self.assertEquals(priorities[i], 7) # Test the priority of all the non-prioritized pieces for i in non_prioritized_pieces: self.assertEquals(priorities[i], 1) # The length of the list of new priorites is the same as the original self.assertEquals(len(priorities_original), len(new_priorites)) #self.print_priority_list(priorities) def test_set_prioritize_first_last_false(self): atp = self.get_torrent_atp("dir_with_6_files.torrent") handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) # First set some pieces prioritized self.torrent.set_prioritize_first_last(True) # Reset pirorities self.torrent.set_prioritize_first_last(False) priorities = handle.piece_priorities() # Test the priority of the prioritized pieces for i in priorities: self.assertEquals(priorities[i], 1)
else: handle = self.session.add_torrent(add_torrent_params) except RuntimeError, e: log.warning("Error adding torrent: %s", e) if not handle or not handle.is_valid(): log.debug("torrent handle is invalid!") # The torrent was not added to the session component.resume("AlertManager") return log.debug("handle id: %s", str(handle.info_hash())) # Set auto_managed to False because the torrent is paused handle.auto_managed(False) # Create a Torrent object torrent = Torrent(handle, options, state, filename, magnet) # Add the torrent object to the dictionary self.torrents[torrent.torrent_id] = torrent if self.config["queue_new_to_top"]: handle.queue_position_top() component.resume("AlertManager") # Store the orignal resume_data, in case of errors. if resume_data: self.resume_data[torrent.torrent_id] = resume_data # Resume the torrent if needed if not options["add_paused"]: torrent.resume()
log.debug("torrent handle is invalid!") # The torrent was not added to the session component.resume("AlertManager") return if log.isEnabledFor(logging.DEBUG): log.debug("handle id: %s", str(handle.info_hash())) # Set auto_managed to False because the torrent is paused handle.auto_managed(False) # Create a Torrent object owner = state.owner if state else ( owner if owner else component.get("RPCServer").get_session_user()) account_exists = component.get("AuthManager").has_account(owner) if not account_exists: owner = 'localclient' torrent = Torrent(handle, options, state, filename, magnet, owner) # Add the torrent object to the dictionary self.torrents[torrent.torrent_id] = torrent if self.config["queue_new_to_top"]: handle.queue_position_top() component.resume("AlertManager") # Resume the torrent if needed if not options["add_paused"]: torrent.resume() # Add to queued torrents set self.queued_torrents.add(torrent.torrent_id)
# The torrent was not added to the session component.resume("AlertManager") return if log.isEnabledFor(logging.DEBUG): log.debug("handle id: %s", str(handle.info_hash())) # Set auto_managed to False because the torrent is paused handle.auto_managed(False) # Create a Torrent object owner = state.owner if state else ( owner if owner else component.get("RPCServer").get_session_user() ) account_exists = component.get("AuthManager").has_account(owner) if not account_exists: owner = 'localclient' torrent = Torrent(handle, options, state, filename, magnet, owner) # Add the torrent object to the dictionary self.torrents[torrent.torrent_id] = torrent if self.config["queue_new_to_top"]: handle.queue_position_top() component.resume("AlertManager") # Resume the torrent if needed if not options["add_paused"]: torrent.resume() # Add to queued torrents set self.queued_torrents.add(torrent.torrent_id)
def test_get_name_unicode(self): """Test retrieving a unicode torrent name from libtorrent.""" atp = self.get_torrent_atp('unicode_file.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) self.assertEqual(self.torrent.get_name(), 'সুকুমার রায়.mkv')
else: handle = self.session.add_torrent(add_torrent_params) except RuntimeError, e: log.warning("Error adding torrent: %s", e) if not handle or not handle.is_valid(): log.debug("torrent handle is invalid!") # The torrent was not added to the session component.resume("AlertManager") return log.debug("handle id: %s", str(handle.info_hash())) # Set auto_managed to False because the torrent is paused handle.auto_managed(False) # Create a Torrent object torrent = Torrent(handle, options, state, filename, magnet) # Add the torrent object to the dictionary self.torrents[torrent.torrent_id] = torrent if self.config["queue_new_to_top"]: handle.queue_position_top() component.resume("AlertManager") # Resume the torrent if needed if not options["add_paused"]: torrent.resume() # Add to queued torrents set self.queued_torrents.add(torrent.torrent_id) # Write the .torrent file to the state directory
class TorrentTestCase(BaseTestCase): def setup_config(self): config_dir = common.set_tmp_config_dir() core_config = deluge.config.Config( 'core.conf', defaults=deluge.core.preferencesmanager.DEFAULT_PREFS, config_dir=config_dir, ) core_config.save() def set_up(self): self.setup_config() self.rpcserver = RPCServer(listen=False) self.core = Core() self.core.config.config['lsd'] = False self.session = lt.session() self.torrent = None return component.start() def tear_down(self): def on_shutdown(result): del self.rpcserver del self.core return component.shutdown().addCallback(on_shutdown) def print_priority_list(self, priorities): tmp = '' for i, p in enumerate(priorities): if i % 100 == 0: print(tmp) tmp = '' tmp += '%s' % p print(tmp) def assert_state(self, torrent, state): torrent.update_state() self.assertEqual(torrent.state, state) def get_torrent_atp(self, filename): filename = common.get_test_data_file(filename) with open(filename, 'rb') as _file: info = lt.torrent_info(lt.bdecode(_file.read())) atp = {'ti': info} atp['save_path'] = os.getcwd() atp['storage_mode'] = lt.storage_mode_t.storage_mode_sparse atp['add_paused'] = False atp['auto_managed'] = True atp['duplicate_is_error'] = True return atp def test_set_prioritize_first_last_pieces(self): piece_indexes = [ 0, 1, 50, 51, 52, 110, 111, 112, 113, 200, 201, 202, 212, 213, 214, 215, 216, 217, 457, 458, 459, 460, 461, 462, ] self.run_test_set_prioritize_first_last_pieces( 'dir_with_6_files.torrent', piece_indexes) def run_test_set_prioritize_first_last_pieces(self, torrent_file, prioritized_piece_indexes): atp = self.get_torrent_atp(torrent_file) handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) priorities_original = handle.piece_priorities() self.torrent.set_prioritize_first_last_pieces(True) priorities = handle.piece_priorities() # The length of the list of new priorites is the same as the original 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.assertEqual(priorities[idx], 7) else: self.assertEqual(priorities[idx], 4) # self.print_priority_list(priorities) def test_set_prioritize_first_last_pieces_false(self): atp = self.get_torrent_atp('dir_with_6_files.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) # First set some pieces prioritized self.torrent.set_prioritize_first_last_pieces(True) # Reset pirorities self.torrent.set_prioritize_first_last_pieces(False) priorities = handle.piece_priorities() # Test the priority of the prioritized pieces for i in priorities: self.assertEqual(priorities[i], 4) # self.print_priority_list(priorities) def test_torrent_error_data_missing(self): if windows_check(): raise unittest.SkipTest( 'unexpected end of file in bencoded string') options = {'seed_mode': True} filename = common.get_test_data_file('test_torrent.file.torrent') with open(filename, 'rb') as _file: filedump = b64encode(_file.read()) torrent_id = self.core.add_torrent_file(filename, filedump, options) torrent = self.core.torrentmanager.torrents[torrent_id] time.sleep(0.5) # Delay to wait for lt to finish check on Travis. self.assert_state(torrent, 'Seeding') # Force an error by reading (non-existant) piece from disk torrent.handle.read_piece(0) time.sleep(0.2) # Delay to wait for alert from lt self.assert_state(torrent, 'Error') def test_torrent_error_resume_original_state(self): if windows_check(): raise unittest.SkipTest( 'unexpected end of file in bencoded string') options = {'seed_mode': True, 'add_paused': True} filename = common.get_test_data_file('test_torrent.file.torrent') with open(filename, 'rb') as _file: filedump = b64encode(_file.read()) torrent_id = self.core.add_torrent_file(filename, filedump, options) torrent = self.core.torrentmanager.torrents[torrent_id] orig_state = 'Paused' self.assert_state(torrent, orig_state) # Force an error by reading (non-existant) piece from disk torrent.handle.read_piece(0) time.sleep(0.2) # Delay to wait for alert from lt self.assert_state(torrent, 'Error') # Clear error and verify returned to original state torrent.force_recheck() def test_torrent_error_resume_data_unaltered(self): if windows_check(): raise unittest.SkipTest( 'unexpected end of file in bencoded string') resume_data = { 'active_time': 13399, 'num_incomplete': 16777215, 'announce_to_lsd': 1, 'seed_mode': 0, 'pieces': '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01', 'paused': 0, 'seeding_time': 13399, 'last_scrape': 13399, 'info-hash': '-\xc5\xd0\xe7\x1af\xfeid\x9ad\r9\xcb\x00\xa2YpIs', 'max_uploads': 16777215, 'max_connections': 16777215, 'num_downloaders': 16777215, 'total_downloaded': 0, 'file-format': 'libtorrent resume file', 'peers6': '', 'added_time': 1411826665, 'banned_peers6': '', 'file_priority': [1], 'last_seen_complete': 0, 'total_uploaded': 0, 'piece_priority': '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01', 'file-version': 1, 'announce_to_dht': 1, 'auto_managed': 1, 'upload_rate_limit': 0, 'completed_time': 1411826665, 'allocation': 'sparse', 'blocks per piece': 2, 'download_rate_limit': 0, 'libtorrent-version': '0.16.17.0', 'banned_peers': '', 'num_seeds': 16777215, 'sequential_download': 0, 'announce_to_trackers': 1, 'peers': '\n\x00\x02\x0f=\xc6SC\x17]\xd8}\x7f\x00\x00\x01=\xc6', 'finished_time': 13399, 'last_upload': 13399, 'trackers': [[]], 'super_seeding': 0, 'file sizes': [[512000, 1411826586]], 'last_download': 13399, } torrent_state = TorrentState( torrent_id='2dc5d0e71a66fe69649a640d39cb00a259704973', filename='test_torrent.file.torrent', name='', save_path='/home/ubuntu/Downloads', file_priorities=[1], is_finished=True, ) filename = common.get_test_data_file('test_torrent.file.torrent') with open(filename, 'rb') as _file: filedump = _file.read() resume_data = utf8_encode_structure(resume_data) torrent_id = self.core.torrentmanager.add( state=torrent_state, filedump=filedump, resume_data=lt.bencode(resume_data)) torrent = self.core.torrentmanager.torrents[torrent_id] def assert_resume_data(): self.assert_state(torrent, 'Error') tm_resume_data = lt.bdecode( self.core.torrentmanager.resume_data[torrent.torrent_id]) self.assertEqual(tm_resume_data, resume_data) return deferLater(reactor, 0.5, assert_resume_data) def test_get_eta_seeding(self): atp = self.get_torrent_atp('test_torrent.file.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) self.assertEqual(self.torrent.get_eta(), 0) self.torrent.status = mock.MagicMock() self.torrent.status.upload_payload_rate = 5000 self.torrent.status.download_payload_rate = 0 self.torrent.status.all_time_download = 10000 self.torrent.status.all_time_upload = 500 self.torrent.is_finished = True self.torrent.options = {'stop_at_ratio': False} # Test finished and uploading but no stop_at_ratio set. self.assertEqual(self.torrent.get_eta(), 0) self.torrent.options = {'stop_at_ratio': True, 'stop_ratio': 1.5} result = self.torrent.get_eta() self.assertEqual(result, 2) self.assertIsInstance(result, int) def test_get_eta_downloading(self): atp = self.get_torrent_atp('test_torrent.file.torrent') handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) self.assertEqual(self.torrent.get_eta(), 0) self.torrent.status = mock.MagicMock() self.torrent.status.download_payload_rate = 50 self.torrent.status.total_wanted = 10000 self.torrent.status.total_wanted_done = 5000 result = self.torrent.get_eta() self.assertEqual(result, 100) self.assertIsInstance(result, int)
class TorrentTestCase(unittest.TestCase): def setup_config(self): global config_setup config_setup = True config_dir = common.set_tmp_config_dir() core_config = deluge.config.Config("core.conf", defaults=deluge.core.preferencesmanager.DEFAULT_PREFS, config_dir=config_dir) core_config.save() def setUp(self): self.setup_config() global rpcserver global core rpcserver = RPCServer(listen=False) core = Core() self.session = lt.session() self.torrent = None return component.start() def tearDown(self): if self.torrent: self.torrent.prev_status_cleanup_loop.stop() def on_shutdown(result): component._ComponentRegistry.components = {} return component.shutdown().addCallback(on_shutdown) def print_priority_list(self, priorities): tmp = '' for i, p in enumerate(priorities): if i % 100 == 0: print tmp tmp = '' tmp += "%s" % p print tmp def get_torrent_atp(self, filename): filename = os.path.join(os.path.dirname(__file__), filename) e = lt.bdecode(open(filename, 'rb').read()) info = lt.torrent_info(e) atp = {"ti": info} atp["save_path"] = os.getcwd() atp["storage_mode"] = lt.storage_mode_t.storage_mode_sparse atp["add_paused"] = False atp["auto_managed"] = True atp["duplicate_is_error"] = True return atp def test_set_prioritize_first_last(self): piece_indexes = [(0,1), (0,1), (0,1), (0,1), (0,2), (50,52), (51,53), (110,112), (111,114), (200,203), (202,203), (212,213), (212,218), (457,463)] self.run_test_set_prioritize_first_last("dir_with_6_files.torrent", piece_indexes) def run_test_set_prioritize_first_last(self, torrent_file, prioritized_piece_indexes): atp = self.get_torrent_atp(torrent_file) handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) priorities_original = handle.piece_priorities() prioritized_pieces, new_priorites = self.torrent.set_prioritize_first_last(True) priorities = handle.piece_priorities() non_prioritized_pieces = list(range(len(priorities))) # The prioritized indexes are the same as we expect self.assertEquals(prioritized_pieces, prioritized_piece_indexes) # Test the priority of the prioritized pieces for first, last in prioritized_pieces: for i in range(first, last): if i in non_prioritized_pieces: non_prioritized_pieces.remove(i) self.assertEquals(priorities[i], 7) # Test the priority of all the non-prioritized pieces for i in non_prioritized_pieces: self.assertEquals(priorities[i], 1) # The length of the list of new priorites is the same as the original self.assertEquals(len(priorities_original), len(new_priorites)) #self.print_priority_list(priorities) def test_set_prioritize_first_last_false(self): atp = self.get_torrent_atp("dir_with_6_files.torrent") handle = self.session.add_torrent(atp) self.torrent = Torrent(handle, {}) # First set some pieces prioritized self.torrent.set_prioritize_first_last(True) # Reset pirorities self.torrent.set_prioritize_first_last(False) priorities = handle.piece_priorities() # Test the priority of the prioritized pieces for i in priorities: self.assertEquals(priorities[i], 1)