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 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 = 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 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_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(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_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(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 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_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 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):
        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 _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']:
                # fucked 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 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")

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)

    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(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