def test_find_candidates_for_all_files_skips_unwanted_exts(self, temp_dir):
piece_length = 32
temp_dir.write('a/b1/a.b1.f1.mp3', ContentManager.generate_random_binary(125).getvalue())
temp_dir.write('a/b1/a.b1.f2.mp3', ContentManager.generate_random_binary(125).getvalue())
temp_dir.write('b/b2/b.b2.f3.mp3', ContentManager.generate_random_binary(267).getvalue())
temp_dir.write('c/c1/c.c1.f1.nfo', ContentManager.generate_random_binary(125).getvalue())
temp_dir.write('c/c1/c.c1.f2.txt', ContentManager.generate_random_binary(267).getvalue())
paths = [self.PathAndLength('a.b1.f1.mp3', 125),
self.PathAndLength('a.b1.f2.mp3', 125),
self.PathAndLength('b.b2.f3.mp3', 267),
self.PathAndLength('c.c1.f1.nfo', 125),
self.PathAndLength('c.c1.f2.txt', 250)]
mock_torrent = MockTorrentFile('name', paths, piece_length)
test_torrent_data_provider = TestTorrentDataProvider([mock_torrent])
recovery = TorrentRecovery([temp_dir.path], DUMMY_DEST_DIR, test_torrent_data_provider)
recovery.start()
self.assertEqual(3, len(recovery.generator.candidates.keys()))
self.assertListEqual([os.path.join(temp_dir.path, 'a', 'b1', 'a.b1.f1.mp3'),
os.path.join(temp_dir.path, 'a', 'b1', 'a.b1.f2.mp3')],
recovery.generator.candidates['a.b1.f1.mp3'])
self.assertListEqual([os.path.join(temp_dir.path, 'a', 'b1', 'a.b1.f1.mp3'),
os.path.join(temp_dir.path, 'a', 'b1', 'a.b1.f2.mp3')],
recovery.generator.candidates['a.b1.f2.mp3'])
self.assertListEqual([os.path.join(temp_dir.path, 'b', 'b2', 'b.b2.f3.mp3')],
recovery.generator.candidates['b.b2.f3.mp3'])
def test_generator_skips_two_not_wanted_files_and_reads_appropriate_data_from_wanted_file(self, temp_dir):
filepaths = ['c/c1/c.c1.f1.nfo', 'c/c1/c.c1.f2.txt', 'c/c1/c.c1.f3.mp3']
piece_length = 32
length_of_valid_file = 567
temp_dir.write(filepaths[0], ContentManager.generate_seq_data(10).getvalue())
temp_dir.write(filepaths[1], ContentManager.generate_seq_data(20).getvalue())
temp_dir.write(filepaths[2], ContentManager.generate_seq_data(length_of_valid_file).getvalue())
paths = [self.PathAndLength('f1.nfo', 10),
self.PathAndLength('f2.txt', 20),
self.PathAndLength('f3.mp3', length_of_valid_file)]
filepaths = [os.path.abspath(os.path.join(temp_dir.path, fp)) for fp in filepaths]
mock_torrent = MockTorrentFile('name', paths, piece_length, real_filepaths=filepaths)
test_torrent_data_provider = TestTorrentDataProvider([mock_torrent])
filepath = os.path.join(temp_dir.path, filepaths[2])
offset = 10 + 20
skipped_pieces = 1 + (offset / piece_length)
file_seek = (skipped_pieces * piece_length) - offset
positions = ContentManager.get_file_positions(length_of_valid_file, piece_length, initial_seek=file_seek)
file_pieces = [ContentManager.get_bytes_from_file(filepath, p[0], p[1]) for p in positions]
recovery = TorrentRecovery([temp_dir.path], DUMMY_DEST_DIR, test_torrent_data_provider)
recovery.start()
self.assertFalse(recovery.generator.torrent_corrupted)
self.assertFalse(recovery.generator.candidate_corrupted)
def test_determine_offsets_skip_only_the_first_file(self, temp_dir):
temp_dir.write(
'a/b1/a.b1.f1',
ContentManager.generate_random_binary(123454).getvalue())
temp_dir.write(
'a/b1/a.b1.f2',
ContentManager.generate_random_binary(123454).getvalue())
temp_dir.write(
'b/b1/b.b1.f1',
ContentManager.generate_random_binary(123455).getvalue())
temp_dir.write('c/c1/c.c1.f1.nfo',
ContentManager.generate_random_binary(12).getvalue())
temp_dir.write('c/c1/c.c1.f2.txt',
ContentManager.generate_random_binary(12).getvalue())
self.file_finder.cache_files_by_size([temp_dir.path])
paths = [
self.PathAndLength('shouldskip1.txt', 123),
self.PathAndLength('path2', 123454),
self.PathAndLength('path3', 123455)
]
mock_torrent = MockTorrentFile('name', paths, 1234567)
generator = Generator(mock_torrent.meta_info, self.file_finder, None,
None)
self.assertEqual(1, len(generator.offsets))
self.assertEqual((0, 123), generator.offsets[0])
def test_generate_random_data(self, temp_dir):
temp_dir.write('b/b1/b.b1.f1', ContentManager.generate_random_binary(123).getvalue())
temp_dir.write('c/c1/c.c1.f1.nfo', ContentManager.generate_random_binary(12).getvalue())
temp_dir.write('c/c1/c.c1.f2.txt', ContentManager.generate_random_binary(14).getvalue())
paths = [self.PathAndLength('path1', 123), self.PathAndLength('path2', 13)]
mock_torrent = MockTorrentFile('name', paths, PIECE_LENGTH)
test_torrent_data_provider = TestTorrentDataProvider([mock_torrent])
recovery = TorrentRecovery([temp_dir.path], DUMMY_DEST_DIR, test_torrent_data_provider)
recovery.start()
# 123 has one candidate, 123789 has 0 -->last_file_marker should be the 123789
self.assertEqual(sum([123]), recovery.generator.actual_pos)
self.assertEqual(123, recovery.generator.last_file_marker)
def test_two_consecutive_not_wanted_files_present_and_nothing_else(
self, temp_dir):
temp_dir.write('a/b1/a.b1.sfv',
ContentManager.generate_random_binary(1).getvalue())
temp_dir.write('a/b1/a.b1.nfo',
ContentManager.generate_random_binary(2).getvalue())
self.file_finder.cache_files_by_size([temp_dir.path])
paths = [
self.PathAndLength('shouldskip1.sfv', 1000),
self.PathAndLength('shouldskip2.nfo', 2000)
]
mock_torrent = MockTorrentFile('name', paths, 123)
generator = Generator(mock_torrent.meta_info, self.file_finder, None,
None)
self.assertEqual(1, len(generator.offsets))
self.assertEqual((0, 3000), generator.offsets[0])
def test_determine_offsets_skip_multiple_files_and_last_file_if_no_candidates_found(
self, temp_dir):
temp_dir.write(
'a/b1/a.b1.f1',
ContentManager.generate_random_binary(125000).getvalue())
temp_dir.write(
'a/b1/a.b1.f2',
ContentManager.generate_random_binary(125000).getvalue())
temp_dir.write(
'b/b1/b.b1.f1',
ContentManager.generate_random_binary(135000).getvalue())
temp_dir.write('c/c1/c.c1.f1.nfo',
ContentManager.generate_random_binary(12).getvalue())
temp_dir.write('c/c1/c.c1.f2.txt',
ContentManager.generate_random_binary(12).getvalue())
self.file_finder.cache_files_by_size([temp_dir.path])
paths = [
self.PathAndLength('shouldskip1.txt', 122),
self.PathAndLength('path2', 125000),
self.PathAndLength('shouldskip2.jpg', 123),
self.PathAndLength('path3', 135000),
self.PathAndLength('shouldskip3.nfo', 124),
self.PathAndLength('shouldskip4.mp3', 23456)
]
mock_torrent = MockTorrentFile('name', paths, 1234567)
generator = Generator(mock_torrent.meta_info, self.file_finder, None,
None)
offset2_start = 122 + 125000
offset3_start = 122 + 125000 + 123 + 135000
offset3_end = offset3_start + 124 + 23456
self.assertEqual(3, len(generator.offsets))
self.assertEqual((0, 122), generator.offsets[0])
self.assertEqual((offset2_start, offset2_start + 123),
generator.offsets[1])
self.assertEqual((offset3_start, offset3_end), generator.offsets[2])
def test_skip_the_loop_if_torrent_corrupted(self, temp_dir):
piece_length = 32
length_of_valid_file = 567
filepaths = ['c/c1/c.c1.f1.nfo', 'a/a1/a.a1.f1.mp3']
temp_dir.write(filepaths[0], ContentManager.generate_seq_data(10).getvalue())
temp_dir.write(filepaths[0], ContentManager.generate_seq_data(length_of_valid_file).getvalue())
paths = [self.PathAndLength('f1.nfo', 10),
self.PathAndLength('f1.mp3', length_of_valid_file)]
filepaths = [os.path.abspath(os.path.join(temp_dir.path, fp)) for fp in filepaths]
mock_torrent = MockTorrentFile('name', paths, piece_length, real_filepaths=filepaths)
test_torrent_data_provider = TestTorrentDataProvider([mock_torrent])
# intentionally make content corrupt after mock torrent pieces hash is created!
ContentManager.write_random_value_to_file(filepaths[0])
recovery = TorrentRecovery([temp_dir.path], DUMMY_DEST_DIR, test_torrent_data_provider)
recovery.start()
self.assertTrue(recovery.generator.torrent_corrupted)
def test_determine_offsets_offset_consecutive_skip_count_as_one_offset(
self, temp_dir):
temp_dir.write(
'a/b1/a.b1.f1',
ContentManager.generate_random_binary(125000).getvalue())
temp_dir.write(
'a/b1/a.b1.f2',
ContentManager.generate_random_binary(125000).getvalue())
temp_dir.write(
'b/b1/b.b1.f1',
ContentManager.generate_random_binary(135000).getvalue())
temp_dir.write('c/c1/c.c1.f1.nfo',
ContentManager.generate_random_binary(12).getvalue())
temp_dir.write('c/c1/c.c1.f2.txt',
ContentManager.generate_random_binary(12).getvalue())
self.file_finder.cache_files_by_size([temp_dir.path])
paths = [
self.PathAndLength('shouldskip1.txt', 122),
self.PathAndLength('shouldskip2.jpg', 123),
self.PathAndLength('path3', 135000),
self.PathAndLength('shouldskip3.nfo', 124)
]
mock_torrent = MockTorrentFile('name', paths, 1234567)
generator = Generator(mock_torrent.meta_info, self.file_finder, None,
None)
offset2_start = 122 + 123 + 135000
self.assertEqual(2, len(generator.offsets))
self.assertEqual((0, 122 + 123), generator.offsets[0])
self.assertEqual((offset2_start, offset2_start + 124),
generator.offsets[1])
def generate_pieces(self, piece_length, real_filepaths):
if real_filepaths == None:
pass
else:
return ContentManager.generate_hash_from_files(real_filepaths)