desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Test that an exception is raised'
| def test_submitter(self):
| self.assertRaises(Exception, exception_generator)
|
'Set up tests'
| def setUp(self):
| self.post_processor = PostProcessor(test.FILE_PATH)
|
'Test file name'
| def test_init_file_name(self):
| self.assertEqual(self.post_processor.file_name, test.FILENAME)
|
'Test folder name'
| def test_init_folder_name(self):
| self.assertEqual(self.post_processor.folder_name, test.SHOW_NAME)
|
'Test process'
| def test_process(self):
| show = TVShow(1, 3)
show.name = test.SHOW_NAME
show.location = test.SHOW_DIR
show.saveToDB()
sickbeard.showList = [show]
episode = TVEpisode(show, test.SEASON, test.EPISODE)
episode.name = u'some episode name'
episode.saveToDB()
addNameToCache(u'show name', 3)
sickbeard.... |
'Test six.text_type
:param name:
:param result:
:return:'
| def _test_unicode(self, name, result):
| name_parser = parser.NameParser(True, showObj=self.show)
parse_result = name_parser.parse(name)
repr(six.text_type(parse_result))
self.assertEqual(parse_result.extra_info, result.extra_info)
|
'Test six.text_type'
| def test_unicode(self):
| for (name, result) in UNICODE_TEST_CASES:
self._test_unicode(name, result)
|
'Test name
:param name:
:return:'
| @staticmethod
def _test_name(name):
| name_parser = parser.NameParser(True)
try:
parse_result = name_parser.parse(name)
except (parser.InvalidNameException, parser.InvalidShowException):
return True
if VERBOSE:
print(u'Actual: ', parse_result.which_regex, parse_result)
return False
|
'Test failures'
| def test_failures(self):
| for name in FAILURE_CASES:
self.assertTrue(self._test_name(name))
|
'Perform combination test
:param name:
:param result:
:param which_regexes:
:return:'
| def _test_combo(self, name, result, which_regexes):
| if VERBOSE:
print()
print(u'Testing', name)
name_parser = parser.NameParser(True)
try:
test_result = name_parser.parse(name)
except parser.InvalidShowException:
return False
if DEBUG:
print(test_result, test_result.which_regex)
print(result, which_rege... |
'Perform combination tests'
| def test_combos(self):
| for (name, result, which_regexes) in COMBINATION_TEST_CASES:
self._test_combo(os.path.normpath(name), result, which_regexes)
|
'Performs a test
:param name_parser: to use for test
:param section:
:param transform:
:param verbose:
:return:'
| def _test_names(self, name_parser, section, transform=None, verbose=False):
| if (VERBOSE or verbose):
print()
print(u'Running', section, u'tests')
for cur_test_base in SIMPLE_TEST_CASES[section]:
if transform:
cur_test = transform(cur_test_base)
name_parser.file_name = cur_test
else:
cur_test = cur_test_base
if ... |
'Test standard names'
| def test_standard_names(self):
| name_parser = parser.NameParser(True)
self._test_names(name_parser, u'standard')
|
'Test standard file names'
| def test_standard_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'standard', (lambda x: (x + u'.avi')))
|
'Test standard repeat names'
| def test_standard_repeat_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'standard_repeat')
|
'Test standard repeat file names'
| def test_standard_repeat_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'standard_repeat', (lambda x: (x + u'.avi')))
|
'Test fov names'
| def test_fov_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'fov')
|
'Test fov file names'
| def test_fov_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'fov', (lambda x: (x + u'.avi')))
|
'Test fov repeat names'
| def test_fov_repeat_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'fov_repeat')
|
'Test fov repeat file names'
| def test_fov_repeat_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'fov_repeat', (lambda x: (x + u'.avi')))
|
'Test stupid names'
| def test_stupid_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'stupid')
|
'Test stupid file names'
| def test_stupid_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'stupid', (lambda x: (x + u'.avi')))
|
'Test no season general names'
| def test_no_s_general_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'no_season_general')
|
'Test no season general file names'
| def test_no_s_general_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'no_season_general', (lambda x: (x + u'.avi')))
|
'Test no season multi episode names'
| def test_no_s_multi_ep_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'no_season_multi_ep')
|
'Test no season multi episode file names'
| def test_no_s_multi_ep_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'no_season_multi_ep', (lambda x: (x + u'.avi')))
|
'Test season only names'
| def test_s_only_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'season_only')
|
'Test season only file names'
| def test_s_only_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'season_only', (lambda x: (x + u'.avi')))
|
'Performs a test
:param name_parser: to use for test
:param section:
:param transform:
:param verbose:
:return:'
| def _test_names(self, name_parser, section, transform=None, verbose=False):
| if (VERBOSE or verbose):
print()
print(u'Running', section, u'tests')
for cur_test_base in ANIME_TEST_CASES[section]:
if transform:
cur_test = transform(cur_test_base)
name_parser.file_name = cur_test
else:
cur_test = cur_test_base
if (... |
'Test anime SxxExx file names'
| def test_anime_sxxexx_file_names(self):
| name_parser = parser.NameParser(parse_method=u'anime')
self._test_names(name_parser, u'anime_SxxExx', (lambda x: (x + u'.avi')))
|
'Performs a test
:param name_parser: to use for test
:param section:
:param transform:
:param verbose:
:return:'
| def _test_names(self, name_parser, section, transform=None, verbose=False):
| if (VERBOSE or verbose):
print()
print(u'Running', section, u'tests')
for cur_test_base in SIMPLE_TEST_CASES[section]:
if transform:
cur_test = transform(cur_test_base)
name_parser.file_name = cur_test
else:
cur_test = cur_test_base
if ... |
'Test no season names'
| def test_no_s_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'no_season')
|
'Test no season file names'
| def test_no_s_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'no_season', (lambda x: (x + u'.avi')))
|
'Test bare names'
| @unittest.expectedFailure
def test_bare_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'bare')
|
'Test bare file names'
| @unittest.expectedFailure
def test_bare_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'bare', (lambda x: (x + u'.avi')))
|
'Test combination names'
| @unittest.skip(u'Not yet implemented')
def test_combination_names(self):
| pass
|
'Test scene date format names'
| @unittest.skip(u'Not trying indexer')
def test_scene_date_fmt_names(self):
| name_parser = parser.NameParser(False)
self._test_names(name_parser, u'scene_date_format')
|
'Test scene date format file names'
| @unittest.skip(u'Not trying indexer')
def test_scene_date_fmt_file_names(self):
| name_parser = parser.NameParser()
self._test_names(name_parser, u'scene_date_format', (lambda x: (x + u'.avi')))
|
'Test SDTV against nameQuality'
| def test_sd_tv(self):
| cur_test = 'sd_tv'
cur_qual = common.Quality.SDTV
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEqual(cur_qual, co... |
'Test SDDVD against nameQuality'
| def test_sd_dvd(self):
| cur_test = 'sd_dvd'
cur_qual = common.Quality.SDDVD
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEqual(cur_qual, ... |
'Test HDTV against nameQuality'
| def test_hd_tv(self):
| cur_test = 'hd_tv'
cur_qual = common.Quality.HDTV
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEqual(cur_qual, co... |
'Test RAWHDTV against nameQuality'
| def test_raw_hd_tv(self):
| cur_test = 'raw_hd_tv'
cur_qual = common.Quality.RAWHDTV
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEqual(cur_q... |
'Test FULLHDTV against nameQuality'
| def test_full_hd_tv(self):
| cur_test = 'full_hd_tv'
cur_qual = common.Quality.FULLHDTV
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEqual(cur... |
'Test HDWEBDL against nameQuality'
| def test_hd_web_dl(self):
| cur_test = 'hd_web_dl'
cur_qual = common.Quality.HDWEBDL
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEqual(cur_q... |
'Test FULLHDWEBDL against nameQuality'
| def test_full_hd_web_dl(self):
| cur_test = 'full_hd_web_dl'
cur_qual = common.Quality.FULLHDWEBDL
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEq... |
'Test HDBLURAY against nameQuality'
| def test_hd_bluray(self):
| cur_test = 'hd_bluray'
cur_qual = common.Quality.HDBLURAY
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEqual(cur_... |
'Test FULLHDBLURAY against nameQuality'
| def test_full_hd_bluray(self):
| cur_test = 'full_hd_bluray'
cur_qual = common.Quality.FULLHDBLURAY
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotE... |
'Test UNKNOWN against nameQuality'
| def test_unknown(self):
| cur_test = 'unknown'
cur_qual = common.Quality.UNKNOWN
for (name, tests) in six.iteritems(self.test_cases):
for test in tests:
if (name == cur_test):
self.assertEqual(cur_qual, common.Quality.nameQuality(test))
else:
self.assertNotEqual(cur_qua... |
'Test Anime against nameQuality'
| def test_anime(self):
| test_cases = {'sd_dvd': ['[DeadFish].Shingeki.no.Kyojin.-.01.-.OVA.[DVD][480p][AAC].mp4'], 'full_hd_bluray': ['[Hatsuyuki-Kaitou]_Shingeki_no_Kyojin_-_Special_02_[BD_1080p][10bit][FLAC][4D908801].mkv']}
test_quality = {'sd_tv': common.Quality.SDTV, 'sd_dvd': common.Quality.SDDVD, 'raw_hd_tv': common.Quality.RAW... |
'Test reverse parsing for all qualities'
| @unittest.expectedFailure
def test_reverse_parsing(self):
| tests = [(common.Quality.SDTV, 'Test Show - S01E02 - SDTV - GROUP'), (common.Quality.SDDVD, 'Test Show - S01E02 - SD DVD - GROUP'), (common.Quality.HDTV, 'Test Show - S01E02 - HDTV - GROUP'), (common.Quality.RAWHDTV, 'Test Show - S01E02 -... |
'Test _getStatusStrings'
| @unittest.skip('Not yet implemented')
def test_get_status_strings(self):
| pass
|
'Test combineQualities'
| @unittest.skip('Not yet implemented')
def test_combine_qualities(self):
| pass
|
'Test splitQuality'
| @unittest.skip('Not yet implemented')
def test_split_quality(self):
| pass
|
'Test nameQuality'
| @unittest.skip('Not yet implemented')
def test_name_quality(self):
| pass
|
'Test scene_quality'
| @unittest.skip('Not yet implemented')
def test_scene_quality(self):
| pass
|
'Test qualityFromFileMeta'
| @unittest.skip('Not yet implemented')
def test_quality_from_file_meta(self):
| pass
|
'Test compositeStatus'
| @unittest.skip('Not yet implemented')
def test_composite_status(self):
| pass
|
'Test qualityDownloaded'
| @unittest.skip('Not yet implemented')
def test_quality_downloaded(self):
| pass
|
'Test splitCompositeStatus'
| @unittest.skip('Not yet implemented')
def test_split_composite_status(self):
| pass
|
'Test sceneQualityFromName'
| @unittest.skip('Not yet implemented')
def test_scene_quality_from_name(self):
| pass
|
'Test statusFromName'
| @unittest.skip('Not yet implemented')
def test_status_from_name(self):
| pass
|
'Run all status strings tests'
| def test_all(self):
| status_strings = common.statusStrings
valid = (1, 112, '1', '112')
unused = (122, 99998989899878676, '99998989899878676', None)
invalid = ('Elephant', (4, 1), [1, 233, 4, None])
for i in valid:
self.assertTrue((i in status_strings))
for i in unused:
self.assertFalse((i in status_... |
'Test common.Overview.overviewStrings'
| def test_overview_strings(self):
| overview = common.Overview()
self.assertEqual(overview.overviewStrings[overview.SKIPPED], 'skipped')
self.assertEqual(overview.overviewStrings[overview.WANTED], 'wanted')
self.assertEqual(overview.overviewStrings[overview.QUAL], 'qual')
self.assertEqual(overview.overviewStrings[overview.GOOD], 'good... |
'Test all possible show names
:param name:
:param indexerid:
:param expected:
:return:'
| def _test_all_possible_show_names(self, name, indexerid=0, expected=None):
| expected = ([] if (expected is None) else expected)
show = Show(1, indexerid)
show.name = name
result = show_name_helpers.allPossibleShowNames(show)
self.assertTrue((len(set(expected).intersection(set(result))) == len(expected)))
|
'Test filter of bad releases
:param name:
:param expected:
:return:'
| def _test_filter_bad_releases(self, name, expected):
| result = show_name_helpers.filter_bad_releases(name)
self.assertEqual(result, expected)
|
'Test all possible show names'
| def test_all_possible_show_names(self):
| test_cache_db_con = db.DBConnection('cache.db')
test_cache_db_con.action('INSERT INTO scene_exceptions (indexer_id, show_name, season) VALUES (?,?,?)', [(-1), 'Exception Test', (-1)])
common.countryList['Full Country Name'] = 'FCN'
self._test_all_possible_show_names('Show ... |
'Test filtering of bad releases'
| def test_filter_bad_releases(self):
| self._test_filter_bad_releases('Show.S02.German.Stuff-Grp', False)
self._test_filter_bad_releases('Show.S02.Some.Stuff-Core2HD', False)
self._test_filter_bad_releases('Show.S02.Some.German.Stuff-Grp', False)
self._test_filter_bad_releases('Show.S02.This.Is.German', False)
|
'Set up tests'
| def setUp(self):
| super(SceneExceptionTestCase, self).setUp()
scene_exceptions.retrieve_exceptions()
|
'Test empty scene exception'
| def test_scene_ex_empty(self):
| self.assertEqual(scene_exceptions.get_scene_exceptions(0), [])
|
'Test scene exceptions for Babylon 5'
| def test_scene_ex_babylon_5(self):
| self.assertEqual(sorted(scene_exceptions.get_scene_exceptions(70726)), ['Babylon 5', 'Babylon5'])
|
'Test scene exceptions by name
:return:'
| def test_scene_ex_by_name(self):
| self.assertEqual(scene_exceptions.get_scene_exception_by_name('Babylon5'), (70726, (-1)))
self.assertEqual(scene_exceptions.get_scene_exception_by_name('babylon 5'), (70726, (-1)))
self.assertEqual(scene_exceptions.get_scene_exception_by_name('Carlos 2010'), (164451, (-1)))
|
'Test scene exceptions by name are empty'
| def test_scene_ex_by_name_empty(self):
| self.assertEqual(scene_exceptions.get_scene_exception_by_name('nothing useful'), (None, None))
|
'Test scene exceptions reset name cache'
| def test_scene_ex_reset_name_cache(self):
| test_cache_db_con = db.DBConnection('cache.db')
test_cache_db_con.action('DELETE FROM scene_exceptions')
name_cache.addNameToCache('Cached Name', 0)
scene_exceptions.retrieve_exceptions()
self.assertEqual(name_cache.retrieveNameFromCache('Cached Name'), 0)
|
'Initialize test'
| def __init__(self, *args, **kwargs):
| super(HelpersTests, self).__init__(*args, **kwargs)
|
'Test makeZip'
| def test_make_zip(self):
| here = os.path.dirname(__file__)
files = [os.path.join(here, f) for f in os.listdir(here) if (f[(-3):] == '.py')]
zip_path = os.path.join(here, '_test.zip')
self.assertTrue(helpers.makeZip(files, zip_path))
self.assertFalse(helpers.makeZip(files, '/:/_test.zip'))
if os.path.isfile(zip_path):
... |
'Test extractZip'
| def test_extract_zip(self):
| here = os.path.dirname(__file__)
files = [os.path.join(here, f) for f in os.listdir(here) if (f[(-3):] == '.py')]
zip_path = os.path.join(here, '_test.zip')
helpers.makeZip(files, zip_path)
extract_path = os.path.join(here, '_extract_test')
self.assertTrue(helpers.extractZip(zip_path, extract_pa... |
'Test backup_config_zip'
| def test_backup_config_zip(self):
| here = os.path.dirname(__file__)
files = [f for f in os.listdir(here) if (f[(-3):] in ['.db', '.py'])]
zip_path = os.path.join(here, '_backup_test.zip')
self.assertTrue(helpers.backup_config_zip(files, zip_path, here))
self.assertFalse(helpers.backup_config_zip(files, '/:/_backup_test.zip'))
if ... |
'Test restore_config_zip'
| def test_restore_config_zip(self):
| here = os.path.dirname(__file__)
files = [f for f in os.listdir(here) if (f[(-3):] in ['.db', '.py'])]
zip_path = os.path.join(here, '_restore_test.zip')
helpers.backup_config_zip(files, zip_path, here)
restore_container = os.path.join(here, '_restore_tests')
os.mkdir(restore_container)
rest... |
'Test is_rar_file'
| def test_is_rar_file(self):
| self.assertTrue(helpers.is_rar_file('lala.rar'))
self.assertFalse(helpers.is_rar_file('lala.zip'))
self.assertFalse(helpers.is_rar_file('lala.iso'))
self.assertFalse(helpers.is_rar_file('lala.wmv'))
self.assertFalse(helpers.is_rar_file('lala.avi'))
self.assertFalse(helpers.is_rar_file('lala.mkv'... |
'Test make_dirs'
| @unittest.skip('Not yet implemented')
def test_make_dirs(self):
| pass
|
'Test delete_empty_folders'
| @unittest.skip('Not yet implemented')
def test_delete_empty_folders(self):
| pass
|
'Test makeDir'
| @unittest.skip('Not yet implemented')
def test_make_dir(self):
| pass
|
'Test is_hidden_folder'
| @unittest.skip('Not yet implemented')
def test_is_hidden_folder(self):
| pass
|
'Test real_path'
| def test_real_path(self):
| self.assertEqual(helpers.real_path('/usr/SickRage/../root/real/path/'), helpers.real_path('/usr/root/real/path/'))
|
'Test is_subdirectory'
| def test_is_subdirectory(self):
| self.assertTrue(helpers.is_subdirectory(subdir_path='/usr/SickRage/Downloads/Unpack', topdir_path='/usr/SickRage/Downloads'))
self.assertTrue(helpers.is_subdirectory(subdir_path='/usr/SickRage/Downloads/testfile.tst', topdir_path='/usr/SickRage/Downloads/'))
self.assertFalse(helpers.is_subdirectory(subdir_p... |
'Test is_media_file'
| def test_is_media_file(self):
| temp_name = 'Show.Name.S01E01.HDTV.x264-RLSGROUP'
extension_tests = {'.'.join((temp_name, ext)): True for ext in MEDIA_EXTENSIONS}
other_extensions = ['txt', 'sfv', 'srr', 'rar', 'nfo', 'zip']
extension_tests.update({'.'.join((temp_name, ext)): False for ext in (other_extensions + SUBTITLE_EXTENSIONS)})... |
'Test is_file_locked'
| @unittest.skip('Not yet implemented')
def test_is_file_locked(self):
| pass
|
'Test remove_file_failed'
| @unittest.skip('Not yet implemented')
def test_remove_file_failed(self):
| pass
|
'Test list_media_files'
| @unittest.skip('Not yet implemented')
def test_list_media_files(self):
| pass
|
'Test copyFile'
| @unittest.skip('Not yet implemented')
def test_copy_file(self):
| pass
|
'Test moveFile'
| @unittest.skip('Not yet implemented')
def test_move_file(self):
| pass
|
'Test rename_ep_file'
| @unittest.skip('Not yet implemented')
def test_rename_ep_file(self):
| pass
|
'Test fileBitFilter'
| @unittest.skip('Not yet implemented')
def test_file_bit_filter(self):
| pass
|
'Test chmodAsParent'
| @unittest.skip('Not yet implemented')
def test_chmod_as_parent(self):
| pass
|
'Test backupVersionedFile'
| @unittest.skip('Not yet implemented')
def test_backup_versioned_file(self):
| pass
|
'Test restoreVersionedFile'
| @unittest.skip('Not yet implemented')
def test_restore_versioned_file(self):
| pass
|
'Test verify_freespace'
| @unittest.skip('Not yet implemented')
def test_verify_free_space(self):
| pass
|
'Test disk_usage'
| @unittest.skip('Not yet implemented')
def test_get_disk_space_usage(self):
| pass
|
'Test download_file'
| @unittest.skip('Not yet implemented')
def test_download_file(self):
| pass
|
'Test get_size'
| @unittest.skip('Not yet implemented')
def test_get_size(self):
| pass
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.