def do_test():
"""
Test to perform
"""
global search_items # pylint: disable=global-statement
search_items = cur_data["i"]
show = TVShow(1, tvdb_id)
show.name = show_name
show.quality = cur_data["q"]
show.saveToDB()
sickbeard.showList.append(show)
episode = None
for epNumber in cur_data["e"]:
episode = TVEpisode(show, cur_data["s"], epNumber)
episode.status = common.WANTED
episode.saveToDB()
best_result = search.searchProviders(show, episode.episode,
force_search)
if not best_result:
assert cur_data["b"] == best_result
# pylint: disable=no-member
assert cur_data[
"b"] == best_result.name # first is expected, second is chosen one
def setUp(self):
super(PPPrivateTests, self).setUp()
sickbeard.showList = [TVShow(1,0000), TVShow(1,0001)]
self.pp = PostProcessor(test.FILEPATH)
self.show_obj = TVShow(1,0002)
self.db = test.db.DBConnection()
newValueDict = {"indexerid": 1002,
"name": test.SHOWNAME,
"description": "description",
"airdate": 1234,
"hasnfo": 1,
"hastbn": 1,
"status": 404,
"location": test.FILEPATH}
controlValueDict = {"showid": 0002,
"season": test.SEASON,
"episode": test.EPISODE}
# use a custom update/insert method to get the data into the DB
self.db.upsert("tv_episodes", newValueDict, controlValueDict)
self.ep_obj = TVEpisode(self.show_obj, test.SEASON, test.EPISODE, test.FILEPATH)
print
def setUpClass(cls):
cls.shows = []
show = TVShow(1, 121361)
show.name = "Italian Works"
show.episodes = []
episode = TVEpisode(show, 05, 10)
episode.name = "Pines of Rome"
episode.scene_season = 5
episode.scene_episode = 10
show.episodes.append(episode)
cls.shows.append(show)
def setUpClass(cls):
cls.shows = []
show = TVShow(1, 121361)
show.name = "Italian Works"
show.episodes = []
episode = TVEpisode(show, 5, 10)
episode.name = "Pines of Rome"
episode.scene_season = 5
episode.scene_episode = 10
show.episodes.append(episode)
cls.shows.append(show)
def test_process(self):
show = TVShow(3)
show.name = test.SHOWNAME
show.location = test.SHOWDIR
show.saveToDB()
sickbeard.showList = [show]
ep = TVEpisode(show, test.SEASON, test.EPISODE)
ep.name = "some ep name"
ep.saveToDB()
pp = PostProcessor(test.FILEPATH)
self.assertTrue(pp.process())
def test_process(self):
show = TVShow(1, 3)
show.name = test.SHOWNAME
show.location = test.SHOWDIR
show.saveToDB()
sickbeard.showList = [show]
ep = TVEpisode(show, test.SEASON, test.EPISODE)
ep.name = "some ep name"
ep.saveToDB()
pp = PostProcessor(test.FILEPATH)
self.assertTrue(pp.process())
def test_process(self):
show = TVShow(1, 3)
show.name = test.SHOWNAME
show.location = test.SHOWDIR
show.saveToDB()
sickbeard.showList = [show]
ep = TVEpisode(show, test.SEASON, test.EPISODE)
ep.name = "some ep name"
ep.saveToDB()
addNameToCache('show name', 3)
self.pp = PostProcessor(test.FILEPATH, process_method='move')
self.assertTrue(self.pp.process())
def test_process(self):
show = TVShow(1, 3)
show.name = SHOWNAME
show.location = SHOWDIR
show.saveToDB()
sickbeard.showList = [show]
ep = TVEpisode(show, SEASON, EPISODE)
ep.name = "some ep name"
ep.saveToDB()
addNameToCache('show name', 3)
self.pp = PostProcessor(FILEPATH, process_method='move')
self.assertTrue(self.pp.process())
def _load_saved_torrents(deleteSaveFile=True):
torrent_save_file = _get_running_torrents_pickle_path(False)
if os.path.isfile(torrent_save_file):
try:
data_from_pickle = pickle.load(open(torrent_save_file, "rb"))
for td in data_from_pickle:
if 'episodes' not in td: # older pickles won't have this
td['episodes'] = []
tvEpObjs = []
for ep in td['episodes']:
shw = helpers.findCertainShow(sickbeard.showList,
ep['tvdbid'])
tvEpObjs.append(
TVEpisode(show=shw,
season=ep['season'],
episode=ep['episode']))
download_from_torrent(torrent=td['torrent'],
postProcessingDone=td['post_processed'],
start_time=td['start_time'],
key=td['key'],
episodes=tvEpObjs)
except Exception, e:
logger.log(
u'Failure while reloading running torrents: %s' % (ex(e)),
logger.ERROR)
if deleteSaveFile:
os.remove(torrent_save_file)
def setUp(self):
super(PPPrivateTests, self).setUp()
sickbeard.showList = [TVShow(1,0000), TVShow(1,0001)]
self.pp = PostProcessor(test.FILEPATH)
self.show_obj = TVShow(1,0002)
self.db = test.db.DBConnection()
newValueDict = {"indexerid": 1002,
"name": test.SHOWNAME,
"description": "description",
"airdate": 1234,
"hasnfo": 1,
"hastbn": 1,
"status": 404,
"location": test.FILEPATH}
controlValueDict = {"showid": 0002,
"season": test.SEASON,
"episode": test.EPISODE}
# use a custom update/insert method to get the data into the DB
self.db.upsert("tv_episodes", newValueDict, controlValueDict)
self.ep_obj = TVEpisode(self.show_obj, test.SEASON, test.EPISODE, test.FILEPATH)
print
def test_getEpisode(self):
show_obj = TVShow(1, 1, 'en')
show_obj.name = 'show name'
show_obj.tvrname = 'show name'
show_obj.network = 'cbs'
show_obj.genre = 'crime'
show_obj.runtime = 40
show_obj.status = '5'
show_obj.airs = 'monday'
show_obj.startyear = 1987
sickbeard.showList = [show_obj]
sickbeard.showDict = {show_obj.sid_int: show_obj}
show_obj.sxe_ep_obj[1] = {}
show_obj.sxe_ep_obj[1][1] = TVEpisode(show_obj, 1, 1, '16)')
show_obj.sxe_ep_obj[1][1].dirty = False
show_obj.sxe_ep_obj[1][1].name = None
self.assertEqual(show_obj.sxe_ep_obj[1][1].dirty, False)
self.assertEqual(
show_obj.sxe_ep_obj[1][1]._format_pattern(
'%SN - %Sx%0E - %EN - %QN'),
'show name - 1x01 - tba - Unknown')
show_obj.sxe_ep_obj[1][1].dirty = False
show_obj.sxe_ep_obj[1][1].name = 'ep name'
self.assertEqual(show_obj.sxe_ep_obj[1][1].dirty, True)
self.assertEqual(
show_obj.sxe_ep_obj[1][1]._format_pattern(
'%SN - %Sx%0E - %EN - %QN'),
'show name - 1x01 - ep name - Unknown')
def test_getEpisode(self):
show = TVShow(1, 1, 'en')
show.name = 'show name'
show.tvrname = 'show name'
show.network = 'cbs'
show.genre = 'crime'
show.runtime = 40
show.status = '5'
show.airs = 'monday'
show.startyear = 1987
sickbeard.showList = [show]
show.episodes[1] = {}
show.episodes[1][1] = TVEpisode(show, 1, 1, '16)')
show.episodes[1][1].dirty = False
show.episodes[1][1].name = None
self.assertEqual(show.episodes[1][1].dirty, False)
self.assertEqual(
show.episodes[1][1]._format_pattern('%SN - %Sx%0E - %EN - %QN'),
'show name - 1x01 - - Unknown')
show.episodes[1][1].dirty = False
show.episodes[1][1].name = 'ep name'
self.assertEqual(show.episodes[1][1].dirty, True)
self.assertEqual(
show.episodes[1][1]._format_pattern('%SN - %Sx%0E - %EN - %QN'),
'show name - 1x01 - ep name - Unknown')
def test_process(self):
show = TVShow(1,3)
show.name = test.SHOWNAME
show.location = test.SHOWDIR
show.saveToDB()
sickbeard.showList = [show]
ep = TVEpisode(show, test.SEASON, test.EPISODE)
ep.name = "some ep name"
ep.saveToDB()
addNameToCache('show name', 3)
sickbeard.PROCESS_METHOD = 'move'
pp = PostProcessor(test.FILEPATH)
self.assertTrue(pp.process())
def test_init_empty_db(self):
show = TVShow(1, 0001, "en")
ep = TVEpisode(show, 1, 1)
ep.name = "asdasdasdajkaj"
ep.saveToDB()
ep.loadFromDB(1, 1)
self.assertEqual(ep.name, "asdasdasdajkaj")
def test_init_empty_db(self):
show = TVShow(1, 1, 'en')
ep = TVEpisode(show, 1, 1)
ep.name = 'asdasdasdajkaj'
ep.saveToDB()
ep.loadFromDB(1, 1)
self.assertEqual(ep.name, 'asdasdasdajkaj')
def test_init_empty_db(self):
show_obj = TVShow(1, 1, 'en')
ep_obj = TVEpisode(show_obj, 1, 1)
ep_obj.name = 'asdasdasdajkaj'
ep_obj.save_to_db()
ep_obj.load_from_db(1, 1)
self.assertEqual(ep_obj.name, 'asdasdasdajkaj')
def test(self):
global searchItems
searchItems = curData["i"]
show = TVShow(tvdbdid)
show.name = show_name
show.quality = curData["q"]
show.saveToDB()
sickbeard.showList.append(show)
for epNumber in curData["e"]:
episode = TVEpisode(show, curData["s"], epNumber)
episode.status = c.WANTED
episode.saveToDB()
bestResult = search.findEpisode(episode, forceSearch)
if not bestResult:
self.assertEqual(curData["b"], bestResult)
self.assertEqual(curData["b"], bestResult.name) #first is expected, second is choosen one
def test(self):
global searchItems
searchItems = curData['i']
show = TVShow(1, tvdbdid)
show.name = show_name
show.quality = curData['q']
show.saveToDB()
sickbeard.showList.append(show)
episode = None
for epNumber in curData['e']:
episode = TVEpisode(show, curData['s'], epNumber)
episode.status = c.WANTED
episode.saveToDB()
bestResult = search.search_providers(show, episode.season, episode.episode, forceSearch)
if not bestResult:
self.assertEqual(curData['b'], bestResult)
self.assertEqual(curData['b'], bestResult.name) #first is expected, second is choosen one
def test_process(self):
"""
Test process
"""
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 = "some episode name"
episode.saveToDB()
addNameToCache('show name', 3)
sickbeard.PROCESS_METHOD = 'move'
post_processor = PostProcessor(test.FILE_PATH)
self.assertTrue(post_processor.process())
def test_process(self):
"""
Test process
"""
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 = "some episode name"
episode.saveToDB()
addNameToCache('show name', 3)
sickbeard.PROCESS_METHOD = 'move'
post_processor = PostProcessor(test.FILE_PATH)
self.assertTrue(post_processor.process())
def subtitles_download_in_pp(): # pylint: disable=too-many-locals, too-many-branches, too-many-statements
"""Check for needed subtitles in the post process folder."""
from sickbeard.tv import TVEpisode
logger.info(u'Checking for needed subtitles in Post-Process folder')
# Check if PP folder is set
if not sickbeard.TV_DOWNLOAD_DIR or not os.path.isdir(sickbeard.TV_DOWNLOAD_DIR):
logger.warning(u'You must set a valid post-process folder in "Post Processing" settings')
return
# Search for all wanted languages
if not wanted_languages():
return
unpack_rar_files(sickbeard.TV_DOWNLOAD_DIR)
run_post_process = False
for root, _, files in os.walk(sickbeard.TV_DOWNLOAD_DIR, topdown=False):
for filename in sorted(files):
# Delete unwanted subtitles before downloading new ones
delete_unwanted_subtitles(root, filename)
if not isMediaFile(filename):
continue
filename = clear_non_release_groups(root, filename)
video_path = os.path.join(root, filename)
tv_episode = TVEpisode.from_filepath(video_path)
if not tv_episode:
logger.debug(u'%s cannot be parsed to an episode', filename)
continue
if not tv_episode.show.subtitles:
logger.debug(u'Subtitle disabled for show: %s. Running post-process to PP it', filename)
run_post_process = True
continue
# 'postpone' should not consider existing subtitles from db.
tv_episode.subtitles = []
downloaded_languages = download_subtitles(tv_episode, video_path=video_path,
subtitles=False, embedded_subtitles=False)
# Don't run post processor unless at least one file has all of the needed subtitles OR
# if user don't want to ignore embedded subtitles and wants to consider 'unknown' as wanted sub,
# and .mkv has one.
if not run_post_process and (
not needs_subtitles(downloaded_languages) or
processTV.has_matching_unknown_subtitles(video_path)):
run_post_process = True
if run_post_process:
logger.info(u'Starting post-process with default settings now that we found subtitles')
processTV.processDir(sickbeard.TV_DOWNLOAD_DIR)
def test(self):
global searchItems
searchItems = curData['i']
show_obj = TVShow(1, tvdbdid)
show_obj.name = show_name
show_obj.quality = curData['q']
show_obj.save_to_db()
sickbeard.showList.append(show_obj)
sickbeard.showDict[show_obj.sid_int] = show_obj
episode = None
for epNumber in curData['e']:
episode = TVEpisode(show_obj, curData['s'], epNumber)
episode.status = c.WANTED
episode.save_to_db()
bestResult = search.search_providers(show_obj, episode.season, episode.episode, forceSearch)
if not bestResult:
self.assertEqual(curData['b'], bestResult)
self.assertEqual(curData['b'], bestResult.name) #first is expected, second is choosen one
def test_init_empty_db(self):
"""
test init empty db
"""
show = TVShow(1, 1, "en")
episode = TVEpisode(show, 1, 1)
episode.name = "asdasdasdajkaj"
episode.saveToDB()
episode.loadFromDB(1, 1)
self.assertEqual(episode.name, "asdasdasdajkaj")
def test_init_empty_db(self):
show = TVShow(1, 1, 'en')
ep = TVEpisode(show, 1, 1)
ep.name = 'asdasdasdajkaj'
ep.saveToDB()
ep.loadFromDB(1, 1)
self.assertEqual(ep.name, 'asdasdasdajkaj')
def test_init_empty_db(self):
show = TVShow(1, 1, "en")
ep = TVEpisode(show, 1, 1)
ep.name = "asdasdasdajkaj"
ep.saveToDB()
ep.loadFromDB(1, 1)
self.assertEqual(ep.name, "asdasdasdajkaj")
def setUp(self):
sickbeard.showList = []
setup_test_db()
setup_test_episode_file()
setup_test_show_dir()
setup_test_processing_dir()
show = TVShow(1, 1, 'en')
show.name = SHOW_NAME
show.location = FILE_DIR
show.episodes = {}
for season in range(1, NUM_SEASONS):
show.episodes[season] = {}
for episode in range(1, EPISODES_PER_SEASON):
if season == SEASON and episode == EPISODE:
episode = TVEpisode(show,
season,
episode,
ep_file=FILE_PATH)
else:
episode = TVEpisode(show, season, episode)
show.episodes[season][episode] = episode
episode.saveToDB()
show.saveToDB()
sickbeard.showList = [show]
def do_test():
"""
Test to perform
"""
global search_items # pylint: disable=global-statement
search_items = cur_data["i"]
show = TVShow(1, tvdb_id)
show.name = show_name
show.quality = cur_data["q"]
show.saveToDB()
sickbeard.showList.append(show)
episode = None
for epNumber in cur_data["e"]:
episode = TVEpisode(show, cur_data["s"], epNumber)
episode.status = common.WANTED
episode.saveToDB()
best_result = search.searchProviders(show, episode.episode, force_search)
if not best_result:
assert cur_data["b"] == best_result
# pylint: disable=no-member
assert cur_data["b"] == best_result.name # first is expected, second is chosen one
def _on_failed_torrent(key, removeFromRunningTorrents=True, markEpisodesWanted=False):
rTorr = _find_running_torrent_by_field('key', key)
if not rTorr:
logger.log(u'Failed to locate torrent with key "%s"' % (key), logger.MESSAGE)
return False
if rTorr['blacklistOrigUrlOnFailure'] and rTorr['originalTorrentUrl']:
_blacklist_torrent_url(rTorr['originalTorrentUrl'])
if markEpisodesWanted:
if rTorr['episodes']:
for ep in rTorr['episodes']:
# f****d up no? We need to do this b/c there's no way to *refresh* from the db without
# actually creating a new TVEpisode object!
epTemp = TVEpisode(show=ep.show, season=ep.season, episode=ep.episode)
if epTemp.status in Quality.SNATCHED + Quality.SNATCHED_PROPER:
logger.log(u'Changing episode %s status from SNATCHED to WANTED' % (epTemp.prettyName()),
logger.MESSAGE)
epTemp.status = WANTED
epTemp.saveToDB()
else:
logger.log(u'NOT Changing episode %s status to WANTED b/c current '
'status is not SNATCHED (actual status is %s)' % (
epTemp.prettyName(), str(epTemp.status)),
logger.MESSAGE)
else:
logger.log(u'Cannot markEpisodesWanted b/c entry has no episodes',
logger.DEBUG)
else:
logger.log(u'Not marking episodes as wanted b/c markEpisodesWanted was False',
logger.DEBUG)
if removeFromRunningTorrents:
_remove_torrent_by_handle(rTorr['handle'], deleteFilesToo=True)
return True
def setUp(self):
sickbeard.showList = []
setup_test_db()
setup_test_episode_file()
setup_test_show_dir()
setup_test_processing_dir()
show = TVShow(1, 0001, 'en')
show.name = SHOW_NAME
show.location = FILE_DIR
show.episodes = {}
for season in range(1, NUM_SEASONS):
show.episodes[season] = {}
for episode in range(1, EPISODES_PER_SEASON):
if season == SEASON and episode == EPISODE:
episode = TVEpisode(show, season, episode, ep_file=FILE_PATH)
else:
episode = TVEpisode(show, season, episode)
show.episodes[season][episode] = episode
episode.saveToDB()
show.saveToDB()
sickbeard.showList = [show]
def test_init_empty_db(self):
"""
test init empty db
"""
show = TVShow(1, 1, "en")
episode = TVEpisode(show, 1, 1)
episode.name = "asdasdasdajkaj"
episode.saveToDB()
episode.loadFromDB(1, 1)
self.assertEqual(episode.name, "asdasdasdajkaj")
def _create_ep(tvid):
show_obj = TVShow(tvid, 3)
show_obj.name = test.SHOWNAME
show_obj.location = test.SHOWDIR
show_obj.save_to_db()
sickbeard.showList = [show_obj]
ep_obj = TVEpisode(show_obj, test.SEASON, test.EPISODE)
ep_obj.name = 'some ep name'
ep_obj.location = '/mnt/hdd/folder/the show/season 01/the show - s01e01 - name.mkv'
ep_obj.save_to_db()
return ep_obj
def _on_failed_torrent(key,
removeFromRunningTorrents=True,
markEpisodesWanted=False):
rTorr = _find_running_torrent_by_field('key', key)
if not rTorr:
logger.log(u'Failed to locate torrent with key "%s"' % (key),
logger.MESSAGE)
return False
if rTorr['blacklistOrigUrlOnFailure'] and rTorr['originalTorrentUrl']:
_blacklist_torrent_url(rTorr['originalTorrentUrl'])
if markEpisodesWanted:
if rTorr['episodes']:
for ep in rTorr['episodes']:
# f****d up no? We need to do this b/c there's no way to *refresh* from the db without
# actually creating a new TVEpisode object!
epTemp = TVEpisode(show=ep.show,
season=ep.season,
episode=ep.episode)
if epTemp.status in Quality.SNATCHED + Quality.SNATCHED_PROPER:
logger.log(
u'Changing episode %s status from SNATCHED to WANTED' %
(epTemp.prettyName()), logger.MESSAGE)
epTemp.status = WANTED
epTemp.saveToDB()
else:
logger.log(
u'NOT Changing episode %s status to WANTED b/c current '
'status is not SNATCHED (actual status is %s)' %
(epTemp.prettyName(), str(epTemp.status)),
logger.MESSAGE)
else:
logger.log(u'Cannot markEpisodesWanted b/c entry has no episodes',
logger.DEBUG)
else:
logger.log(
u'Not marking episodes as wanted b/c markEpisodesWanted was False',
logger.DEBUG)
if removeFromRunningTorrents:
_remove_torrent_by_handle(rTorr['handle'], deleteFilesToo=True)
return True
class PPPrivateTests(test.SickbeardTestDBCase):
def setUp(self):
super(PPPrivateTests, self).setUp()
sickbeard.showList = [TVShow(1, 0000), TVShow(1, 0001)]
self.pp = PostProcessor(test.FILEPATH)
self.show_obj = TVShow(1, 0002)
self.db = test.db.DBConnection()
newValueDict = {
"indexerid": 1002,
"name": test.SHOWNAME,
"description": "description",
"airdate": 1234,
"hasnfo": 1,
"hastbn": 1,
"status": 404,
"location": test.FILEPATH
}
controlValueDict = {
"showid": 0002,
"season": test.SEASON,
"episode": test.EPISODE
}
# use a custom update/insert method to get the data into the DB
self.db.upsert("tv_episodes", newValueDict, controlValueDict)
self.ep_obj = TVEpisode(self.show_obj, test.SEASON, test.EPISODE,
test.FILEPATH)
print
def test__find_ep_destination_folder(self):
self.show_obj.location = test.FILEDIR
self.ep_obj.show.seasonfolders = 1
sickbeard.SEASON_FOLDERS_FORMAT = 'Season %02d'
calculatedPath = self.ep_obj.proper_path()
expectedPath = os.path.join(test.FILEDIR,
"Season 0" + str(test.SEASON))
self.assertEqual(calculatedPath, expectedPath)
def setUpClass(cls):
num_legacy_shows = 3
num_shows = 3
num_episodes_per_show = 5
cls.mydb = db.DBConnection()
cls.legacy_shows = []
cls.shows = []
# Per-show-notifications were originally added for email notifications only. To add
# this feature to other notifiers, it was necessary to alter the way text is stored in
# one of the DB columns. Therefore, to test properly, we must create some shows that
# store emails in the old method (legacy method) and then other shows that will use
# the new method.
for show_counter in range(100, 100 + num_legacy_shows):
show = TVShow(1, show_counter)
show.name = "Show " + str(show_counter)
show.episodes = []
for episode_counter in range(0, num_episodes_per_show):
episode = TVEpisode(show, test.SEASON, episode_counter)
episode.name = "Episode " + str(episode_counter + 1)
episode.quality = "SDTV"
show.episodes.append(episode)
show.saveToDB()
cls.legacy_shows.append(show)
for show_counter in range(200, 200 + num_shows):
show = TVShow(1, show_counter)
show.name = "Show " + str(show_counter)
show.episodes = []
for episode_counter in range(0, num_episodes_per_show):
episode = TVEpisode(show, test.SEASON, episode_counter)
episode.name = "Episode " + str(episode_counter + 1)
episode.quality = "SDTV"
show.episodes.append(episode)
show.saveToDB()
cls.shows.append(show)
class PPPrivateTests(test.SickbeardTestDBCase):
def setUp(self):
super(PPPrivateTests, self).setUp()
sickbeard.showList = [TVShow(1,0000), TVShow(1,0001)]
self.pp = PostProcessor(test.FILEPATH)
self.show_obj = TVShow(1,0002)
self.db = test.db.DBConnection()
newValueDict = {"indexerid": 1002,
"name": test.SHOWNAME,
"description": "description",
"airdate": 1234,
"hasnfo": 1,
"hastbn": 1,
"status": 404,
"location": test.FILEPATH}
controlValueDict = {"showid": 0002,
"season": test.SEASON,
"episode": test.EPISODE}
# use a custom update/insert method to get the data into the DB
self.db.upsert("tv_episodes", newValueDict, controlValueDict)
self.ep_obj = TVEpisode(self.show_obj, test.SEASON, test.EPISODE, test.FILEPATH)
print
def test__find_ep_destination_folder(self):
self.show_obj.location = test.FILEDIR
self.ep_obj.show.seasonfolders = 1
sickbeard.SEASON_FOLDERS_FORMAT = 'Season %02d'
calculatedPath = self.ep_obj.proper_path()
expectedPath = os.path.join(test.FILEDIR, "Season 0" + str(test.SEASON))
self.assertEqual(calculatedPath, expectedPath)
def test_process(self):
show_obj = TVShow(1, 3)
show_obj.tvid = TVINFO_TVDB
show_obj.name = test.SHOWNAME
show_obj.location = test.SHOWDIR
show_obj.save_to_db()
sickbeard.showList = [show_obj]
ep_obj = TVEpisode(show_obj, test.SEASON, test.EPISODE)
ep_obj.name = 'some ep name'
ep_obj.release_name = 'test setter'
ep_obj.save_to_db()
addNameToCache('show name', tvid=TVINFO_TVDB, prodid=3)
sickbeard.PROCESS_METHOD = 'move'
pp = PostProcessor(test.FILEPATH)
self.assertTrue(pp.process())
def test(self):
self.showDir = test_lib.setUp_test_show_dir(show_name)
self.filePath = test_lib.setUp_test_episode_file(
None, curData["b"] + ".mkv")
show = TVShow(tvdbdid)
show.name = show_name
show.quality = curData["q"]
show.location = self.showDir
if curData["anime"]:
show.anime = 1
show.saveToDB()
sickbeard.showList.append(show)
for epNumber in curData["e"]:
episode = TVEpisode(show, curData["s"], epNumber)
episode.status = c.WANTED
if "ab" in curData:
episode.absolute_number = curData["ab"]
episode.saveToDB()
pp = PostProcessor(self.filePath)
self.assertTrue(pp.process())
def setUpClass(cls):
num_legacy_shows = 3
num_shows = 3
num_episodes_per_show = 5
cls.mydb = db.DBConnection()
cls.legacy_shows = []
cls.shows = []
# Per-show-notifications were originally added for email notifications only. To add
# this feature to other notifiers, it was necessary to alter the way text is stored in
# one of the DB columns. Therefore, to test properly, we must create some shows that
# store emails in the old method (legacy method) and then other shows that will use
# the new method.
for show_counter in range(100, 100+num_legacy_shows):
show = TVShow(1, show_counter)
show.name = "Show "+str(show_counter)
show.episodes = []
for episode_counter in range(0, num_episodes_per_show):
episode = TVEpisode(show, test.SEASON, episode_counter)
episode.name = "Episode "+str(episode_counter+1)
episode.quality = "SDTV"
show.episodes.append(episode)
show.saveToDB()
cls.legacy_shows.append(show)
for show_counter in range(200, 200+num_shows):
show = TVShow(1, show_counter)
show.name = "Show "+str(show_counter)
show.episodes = []
for episode_counter in range(0, num_episodes_per_show):
episode = TVEpisode(show, test.SEASON, episode_counter)
episode.name = "Episode "+str(episode_counter+1)
episode.quality = "SDTV"
show.episodes.append(episode)
show.saveToDB()
cls.shows.append(show)
def test(self):
show = TVShow(1, int(curData["tvdbid"]))
show.name = name
show.quality = c.ANY | c.Quality.UNKNOWN | c.Quality.RAWHDTV
show.saveToDB()
sickbeard.showList.append(show)
for epNumber in curData["e"]:
episode = TVEpisode(show, curData["s"], epNumber)
episode.status = c.WANTED
# We arent updating scene numbers, so fake it here
episode.scene_season = curData["s"]
episode.scene_episode = epNumber
episode.saveToDB()
provider.show = show
season_strings = provider._get_season_search_strings(episode)
episode_strings = provider._get_episode_search_strings(episode)
fail = False
for cur_string in season_strings, episode_strings:
if not all([isinstance(cur_string, list), isinstance(cur_string[0], dict)]):
print " %s is using a wrong string format!" % provider.name
print cur_string
fail = True
continue
if fail:
continue
try:
assert(season_strings == curData["s_strings"])
assert(episode_strings == curData["e_strings"])
except AssertionError:
print " %s is using a wrong string format!" % provider.name
print cur_string
continue
search_strings = episode_strings[0]
#search_strings.update(season_strings[0])
#search_strings.update({"RSS":['']})
#print search_strings
if not provider.public:
continue
items = provider._doSearch(search_strings)
if not items:
print "No results from provider?"
continue
title, url = provider._get_title_and_url(items[0])
for word in show.name.split(" "):
if not word.lower() in title.lower():
print "Show name not in title: %s. URL: %s" % (title, url)
continue
if not url:
print "url is empty"
continue
quality = provider.getQuality(items[0])
size = provider._get_size(items[0])
if not show.quality & quality:
print "Quality not in common.ANY, %r" % quality
continue
def do_test(self):
"""
Test to perform
"""
show = TVShow(1, int(cur_data["tvdbid"]))
show.name = cur_name
show.quality = common.ANY | common.Quality.UNKNOWN | common.Quality.RAWHDTV
show.saveToDB()
sickbeard.showList.append(show)
for ep_number in cur_data["e"]:
episode = TVEpisode(show, cur_data["s"], ep_number)
episode.status = common.WANTED
# We aren't updating scene numbers, so fake it here
episode.scene_season = cur_data["s"]
episode.scene_episode = ep_number
episode.saveToDB()
cur_provider.show = show
season_strings = cur_provider._get_season_search_strings(episode) # pylint: disable=protected-access
episode_strings = cur_provider._get_episode_search_strings(episode) # pylint: disable=protected-access
fail = False
cur_string = ''
for cur_string in season_strings, episode_strings:
if not all([
isinstance(cur_string, list),
isinstance(cur_string[0], dict)
]):
print " {0!s} is using a wrong string format!".format(
cur_provider.name)
print cur_string
fail = True
continue
if fail:
continue
try:
assert season_strings == cur_data["s_strings"]
assert episode_strings == cur_data["e_strings"]
except AssertionError:
print " {0!s} is using a wrong string format!".format(
cur_provider.name)
print cur_string
continue
search_strings = episode_strings[0]
# search_strings.update(season_strings[0])
# search_strings.update({"RSS":['']})
# print search_strings
if not cur_provider.public:
continue
items = cur_provider.search(search_strings) # pylint: disable=protected-access
if not items:
print "No results from cur_provider?"
continue
title, url = cur_provider._get_title_and_url(items[0]) # pylint: disable=protected-access
for word in show.name.split(" "):
if not word.lower() in title.lower():
print "Show cur_name not in title: {0!s}. URL: {1!s}".format(
title, url)
continue
if not url:
print "url is empty"
continue
quality = cur_provider.get_quality(items[0])
size = cur_provider._get_size(items[0]) # pylint: disable=protected-access
if not show.quality & quality:
print "Quality not in common.ANY, {0!r} {1!s}".format(
quality, size)
continue
def do_test():
"""
Test to perform
"""
show = TVShow(1, int(cur_data["tvdbid"]))
show.name = cur_name
show.quality = common.ANY | common.Quality.UNKNOWN | common.Quality.RAWHDTV
show.saveToDB()
sickbeard.showList.append(show)
for ep_number in cur_data["e"]:
episode = TVEpisode(show, cur_data["s"], ep_number)
episode.status = common.WANTED
# We aren't updating scene numbers, so fake it here
episode.scene_season = cur_data["s"]
episode.scene_episode = ep_number
episode.saveToDB()
cur_provider.show = show
season_strings = cur_provider._get_season_search_strings(episode) # pylint: disable=protected-access
episode_strings = cur_provider._get_episode_search_strings(episode) # pylint: disable=protected-access
fail = False
cur_string = ''
for cur_string in season_strings, episode_strings:
if not all([isinstance(cur_string, list), isinstance(cur_string[0], dict)]):
print " %s is using a wrong string format!" % cur_provider.name
print cur_string
fail = True
continue
if fail:
continue
try:
assert season_strings == cur_data["s_strings"]
assert episode_strings == cur_data["e_strings"]
except AssertionError:
print " %s is using a wrong string format!" % cur_provider.name
print cur_string
continue
search_strings = episode_strings[0]
# search_strings.update(season_strings[0])
# search_strings.update({"RSS":['']})
# print search_strings
if not cur_provider.public:
continue
items = cur_provider._doSearch(search_strings) # pylint: disable=protected-access
if not items:
print "No results from cur_provider?"
continue
title, url = cur_provider._get_title_and_url(items[0]) # pylint: disable=protected-access
for word in show.name.split(" "):
if not word.lower() in title.lower():
print "Show cur_name not in title: %s. URL: %s" % (title, url)
continue
if not url:
print "url is empty"
continue
quality = cur_provider.getQuality(items[0])
size = cur_provider._get_size(items[0]) # pylint: disable=protected-access
if not show.quality & quality:
print "Quality not in common.ANY, %r %s" % (quality, size)
continue
def test_getWanted(self):
for ep_base, w in enumerate(wanted_tests):
show_obj = TVShow(w['show']['indexer'], w['show']['indexerid'],
'en')
show_obj.name = 'show name'
show_obj.tvrname = 'show name'
show_obj.quality = w['show']['quality']
show_obj.network = 'cbs'
show_obj.genre = 'crime'
show_obj.runtime = 40
show_obj.status = '5'
show_obj.airs = 'monday'
show_obj.startyear = 1987
show_obj.save_to_db()
sickbeard.showList = [show_obj]
sickbeard.showDict[show_obj.sid_int] = show_obj
cl = []
ep_id = ep_base * 10000
for ep in w['episodes']:
ep_id += 1
if ep['season'] not in show_obj.sxe_ep_obj:
show_obj.sxe_ep_obj[ep['season']] = {}
show_obj.sxe_ep_obj[ep['season']][ep['episode']] = TVEpisode(
show_obj, ep['season'], ep['episode'])
episode = show_obj.sxe_ep_obj[ep['season']][ep['episode']]
episode.status = Quality.compositeStatus(
ep['status'], ep['quality'])
episode.airdate = ep['airdate']
episode.name = 'nothing'
episode.epid = ep_id
episode.show_obj = show_obj
episode.tvid = show_obj.tvid
cl.append(episode.get_sql())
cur_db = db.DBConnection()
if cl:
cur_db.mass_action(cl)
qi = QueueItemAdd(w['show']['indexer'], w['show']['indexerid'], '',
None, Quality.NONE, None, None, None, False,
False, False, None, None, w['start_wanted'],
w['end_wanted'], None, None)
qi.show_obj = show_obj
# start tests
tr = qi._get_wanted(cur_db, w['start_wanted'], False)
self.assertEqual(
tr,
w['result']['start'].get('count'),
msg='%s: start: got: %s, expected: %s' %
(w['name'], tr, w['result']['start'].get('count')))
results = cur_db.select(
'SELECT status, season, episode FROM tv_episodes WHERE indexer = ? AND showid = ?'
' ORDER BY season, episode', [show_obj.tvid, show_obj.prodid])
for r in results:
expected = w['result']['start'].get('episodes').get(
r['season'], {}).get(r['episode'], None)
self.assertEqual(
r['status'],
expected,
msg='%s: start %sx%s: got: %s, expected: %s' %
(w['name'], r['season'], r['episode'],
statusStrings[r['status']], statusStrings[expected]))
# end tests
tr = qi._get_wanted(cur_db, w['end_wanted'], True)
self.assertEqual(tr,
w['result']['end'].get('count'),
msg='%s: end: got: %s, expected: %s' %
(w['name'], tr, w['result']['end'].get('count')))
results = cur_db.select(
'SELECT status, season, episode FROM tv_episodes WHERE indexer = ? AND showid = ?'
' ORDER BY season, episode', [show_obj.tvid, show_obj.prodid])
for r in results:
expected = w['result']['end'].get('episodes').get(
r['season'], {}).get(r['episode'], None)
self.assertEqual(
r['status'],
expected,
msg='%s: end %sx%s: got: %s, expected: %s' %
(w['name'], r['season'], r['episode'],
statusStrings[r['status']], statusStrings[expected]))
def test(self):
show = TVShow(1, int(curData["tvdbid"]))
show.name = name
show.quality = c.ANY | c.Quality.UNKNOWN | c.Quality.RAWHDTV
show.saveToDB()
sickbeard.showList.append(show)
for epNumber in curData["e"]:
episode = TVEpisode(show, curData["s"], epNumber)
episode.status = c.WANTED
# We arent updating scene numbers, so fake it here
episode.scene_season = curData["s"]
episode.scene_episode = epNumber
episode.saveToDB()
provider.show = show
season_strings = provider._get_season_search_strings(episode)
episode_strings = provider._get_episode_search_strings(episode)
fail = False
for cur_string in season_strings, episode_strings:
if not all([
isinstance(cur_string, list),
isinstance(cur_string[0], dict)
]):
print " %s is using a wrong string format!" % provider.name
print cur_string
fail = True
continue
if fail:
continue
try:
assert (season_strings == curData["s_strings"])
assert (episode_strings == curData["e_strings"])
except AssertionError:
print " %s is using a wrong string format!" % provider.name
print cur_string
continue
search_strings = episode_strings[0]
#search_strings.update(season_strings[0])
#search_strings.update({"RSS":['']})
#print search_strings
if not provider.public:
continue
items = provider._doSearch(search_strings)
if not items:
print "No results from provider?"
continue
title, url = provider._get_title_and_url(items[0])
for word in show.name.split(" "):
if not word.lower() in title.lower():
print "Show name not in title: %s. URL: %s" % (title, url)
continue
if not url:
print "url is empty"
continue
quality = provider.getQuality(items[0])
size = provider._get_size(items[0])
if not show.quality & quality:
print "Quality not in common.ANY, %r" % quality
continue
