# coding=UTF-8 # Author: # URL: https://github.com/SickGear/SickGear # # This file is part of SickGear. # # SickGear is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # SickGear is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with SickGear. If not, see <http://www.gnu.org/licenses/>. import datetime import itertools import os import unittest import warnings import sys import test_lib as test warnings.filterwarnings('ignore', module=r'.*ssl_.*', message='.*SSLContext object.*') import sickgear from exceptions_helper import ex from sickgear.classes import SearchResult from sickgear.common import Quality, ARCHIVED, DOWNLOADED, WANTED, UNAIRED, SNATCHED, SNATCHED_PROPER, SNATCHED_BEST, \ SNATCHED_ANY, SUBTITLED, statusStrings, UNKNOWN from sickgear.event_queue import Events from sickgear.tv import TVEpisode, TVShow from sickgear.webserveInit import WebServer from sickgear import webapi, scheduler, search_backlog, search_queue, show_queue, history, db from sickgear.scene_numbering import set_scene_numbering_helper from lib import requests from six import integer_types, iteritems, iterkeys, itervalues, string_types # noinspection PyUnreachableCode if False: from typing import Any, AnyStr NoneType = type(None) today = datetime.date.today() last_week = today - datetime.timedelta(days=5) old_date = today - datetime.timedelta(days=14) future = today + datetime.timedelta(days=1) far_future = today + datetime.timedelta(days=30) if 'win32' == sys.platform: root_folder_tests = [ # root_dirs, path, expected ('1|C:\\dir', 'C:\\folder', None), ('1|c:\\dir', 'c:\\dir', 'c:\\dir'), ('1|c:\\dir2', 'c:\\dir2\\dir', 'c:\\dir2'), ('1|c:\\tv_complete|c:\\tv', 'c:\\tv', 'c:\\tv') ] else: root_folder_tests = [ # root_dirs, path, expected ('1|~/dir', '~/dir/dir', '~/dir'), ('1|/mnt/hdd/dir', '/mnt/hdd/folder', None), ('1|/mnt/hdd/dir', '/mnt/hdd/dir', '/mnt/hdd/dir'), ('1|/mnt/hdd/dir2', '/mnt/hdd/dir2/dir', '/mnt/hdd/dir2'), ('1|/mnt/hdd/tv_complete|/mnt/hdd/tv', '/mnt/hdd/tv', '/mnt/hdd/tv') ] test_shows = [ {'tvid': 1, 'prodid': 1234, 'name': 'Test Show', 'runtime': 45, 'airs': 'Mondays, 00:45', 'imdbid': 'tt1234567', '_location': r'C:\series\show dir', 'network': 'Network', 'overview': 'Overview text', 'status': 'Continuing', 'quality_init': [], 'quality_upgrade': [], 'episodes': { 1: { 1: {'name': 'ep1', 'status': Quality.composite_status(DOWNLOADED, Quality.HDWEBDL), 'airdate': old_date, 'description': 'ep1 description'}, 2: {'name': 'ep2', 'status': WANTED, 'airdate': last_week, 'description': 'ep2 description'}, 3: {'name': 'ep3', 'status': WANTED, 'airdate': today, 'description': 'ep3 description'}, 4: {'name': 'ep4', 'status': UNAIRED, 'airdate': future, 'description': 'ep4 description'}, 5: {'name': 'ep5', 'status': UNAIRED, 'airdate': far_future, 'description': 'ep5 description'}, } } }, {'tvid': 1, 'prodid': 5678, 'name': 'Test Show 2', 'runtime': 45, 'airs': 'Tuesdays, 22:15', 'imdbid': 'tt7775567', '_location': r'C:\series\show 2', 'network': 'Network 2', 'overview': 'Overview text 2', 'status': 'Continuing', 'quality_init': [Quality.HDTV, Quality.FULLHDWEBDL], 'quality_upgrade': [Quality.FULLHDWEBDL], 'episodes': { 1: { 1: {'name': 'new ep1', 'status': UNAIRED, 'airdate': far_future, 'description': 'ep1 description'}, 2: {'name': 'new ep2', 'status': UNAIRED, 'airdate': far_future + datetime.timedelta(days=7), 'description': 'ep2 description'}, 3: {'name': 'new ep3', 'status': UNAIRED, 'airdate': far_future + datetime.timedelta(days=14), 'description': 'ep3 description'}, 4: {'name': 'new ep4', 'status': UNAIRED, 'airdate': far_future + datetime.timedelta(days=28), 'description': 'ep4 description'}, 5: {'name': 'new ep5', 'status': UNAIRED, 'description': 'ep5 description'}, } } }, ] def fake_action(*args, **kwargs): pass class fake_class(): pass class WebAPICase(test.SickbeardTestDBCase): webserver = None instance = None def __init__(self, *args, **kwargs): super(WebAPICase, self).__init__(*args, **kwargs) self.org_mass_action = None self.show_save_db = None @classmethod def setUpClass(cls): super(WebAPICase, cls).setUpClass() # web server options sickgear.WEB_PORT = 8080 cls.web_options = dict( host='127.0.0.1', port=sickgear.WEB_PORT, web_root=None, data_root=os.path.join(sickgear.PROG_DIR, 'gui', sickgear.GUI_NAME), log_dir=sickgear.LOG_DIR, username=sickgear.WEB_USERNAME, password=sickgear.WEB_PASSWORD, handle_reverse_proxy=sickgear.HANDLE_REVERSE_PROXY, enable_https=False, https_cert=None, https_key=None, ) # start web server try: # used to check if existing SG instances have been started sickgear.helpers.wait_for_free_port( sickgear.WEB_IPV6 and '::1' or cls.web_options['host'], cls.web_options['port']) cls.webserver = WebServer(options=cls.web_options) cls.webserver.start() # wait for server thread to be started cls.webserver.wait_server_start() cls.webserver.switch_handlers() sickgear.started = True sickgear.API_KEYS = [['unit test key', '1234567890']] sickgear.USE_API = True sickgear.process_media_scheduler = fake_class() sickgear.update_show_scheduler = fake_class() sickgear.process_media_scheduler.is_running_job = False sickgear.update_show_scheduler.is_running_job = False except (BaseException, Exception) as e: print('Failed to start WebServer: %s' % ex(e)) @classmethod def tearDownClass(cls): super(WebAPICase, cls).tearDownClass() # shutdown web server if cls.webserver: cls.webserver.shut_down() try: cls.webserver.join(10) except (BaseException, Exception): pass if cls.instance: super(WebAPICase, cls.instance).tearDown() def setUp(self): self.reset_show_data = False self.org_mass_action = None self.show_save_db = None if not WebAPICase.instance: WebAPICase.instance = self super(WebAPICase, self).setUp() sickgear.events = Events(None) sickgear.show_queue_scheduler = scheduler.Scheduler( show_queue.ShowQueue(), cycle_time=datetime.timedelta(seconds=3), thread_name='SHOWQUEUE') sickgear.search_queue_scheduler = scheduler.Scheduler( search_queue.SearchQueue(), cycle_time=datetime.timedelta(seconds=3), thread_name='SEARCHQUEUE') sickgear.search_backlog_scheduler = search_backlog.BacklogSearchScheduler( search_backlog.BacklogSearcher(), cycle_time=datetime.timedelta(minutes=60), run_delay=datetime.timedelta(minutes=60), thread_name='BACKLOG') sickgear.indexermapper.indexer_list = [i for i in sickgear.indexers.indexer_api.TVInfoAPI().all_sources] for root_dirs, path, expected in root_folder_tests: sickgear.ROOT_DIRS = root_dirs for cur_show in test_shows: show_obj = TVShow(cur_show['tvid'], cur_show['prodid']) for k, v in iteritems(cur_show): if k in ('tvid', 'prodid', 'episodes', 'quality_init', 'quality_upgrade'): continue if '_%s' % k in show_obj.__dict__: show_obj.__dict__['_%s' % k] = v elif k in show_obj.__dict__: show_obj.__dict__[k] = v if 'quality_init' in cur_show and cur_show['quality_init']: show_obj.quality = Quality.combine_qualities(cur_show['quality_init'], cur_show.get('quality_upgrade', [])) show_obj.dirty = True show_obj.save_to_db(True) sickgear.showList.append(show_obj) sickgear.showDict.update({show_obj.sid_int: show_obj}) for season, eps in iteritems(cur_show['episodes']): for ep, data in iteritems(eps): ep_obj = TVEpisode(show_obj, season, ep) for k, v in iteritems(data): if '_%s' % k in ep_obj.__dict__: ep_obj.__dict__['_%s' % k] = v elif k in ep_obj.__dict__: ep_obj.__dict__[k] = v show_obj.sxe_ep_obj.setdefault(season, {})[ep] = ep_obj ep_obj.save_to_db(True) status, quality = Quality.split_composite_status(ep_obj.status) if status in (DOWNLOADED, SNATCHED): s_r = SearchResult([ep_obj]) s_r.show_obj, s_r.quality, s_r.provider, s_r.name = \ show_obj, quality, None, '%s.S%sE%s.group' % ( show_obj.name, ep_obj.season, ep_obj.episode) history.log_snatch(s_r) if DOWNLOADED == status: history.log_download(ep_obj, '%s.S%sE%s.group.mkv' % ( show_obj.name, ep_obj.season, ep_obj.episode), quality, 'group') sickgear.webserve.Home.make_showlist_unique_names() def tearDown(self): if None is not self.org_mass_action: db.DBConnection.mass_action = self.org_mass_action if None is not self.show_save_db: sickgear.tv.TVShow.save_to_db = self.show_save_db sickgear.show_queue_scheduler.action.queue = [] sickgear.search_queue_scheduler.action.queue = [] if self.reset_show_data: for cur_show in test_shows: show_obj = sickgear.helpers.find_show_by_id({cur_show['tvid']: cur_show['prodid']}) if 'quality_init' in cur_show and cur_show['quality_init']: show_obj.quality = Quality.combine_qualities(cur_show['quality_init'], cur_show.get('quality_upgrade', [])) else: show_obj.quality = int(sickgear.QUALITY_DEFAULT) show_obj.upgrade_once = int(cur_show.get('upgrade_once', 0)) show_obj.scene = int(cur_show.get('scene', 0)) show_obj.save_to_db() for season, data in iteritems(cur_show['episodes']): for ep_nb, cur_ep in iteritems(data): ep_obj = show_obj.get_episode(season, ep_nb) ep_obj.status = cur_ep.get('status') ep_obj.save_to_db() set_scene_numbering_helper( cur_show['tvid'], cur_show['prodid'], season, ep_nb, scene_season=cur_ep.get('scene_season'), scene_episode=cur_ep.get('scene_episode')) @staticmethod def _request_from_api(cmd, params=None): param = {'cmd': webapi._functionMaper_reversed[cmd]} if isinstance(params, dict): param.update(params) return requests.get('http://127.0.0.1:%s/api/%s' % (sickgear.WEB_PORT, sickgear.API_KEYS[0][1]), params=param).json() @staticmethod def _check_types(data, fields): result, msg = True, [] missing_list, wrong_type = [], {} for f in fields: if f[0] not in data: missing_list.append(f[0]) result = False elif not isinstance(data[f[0]], f[1]): wrong_type[f[0]] = 'Expected: %s, Got: %s' % (type(data[f[0]]), str(f[1])) result = False if missing_list: msg.append('Missing fields: %s' % ', '.join(missing_list)) if wrong_type: msg.append('Wrong field type: %s' % ', '.join(['%s: %s' % (k, v) for k, v in iteritems(wrong_type)])) return result, ('', ', %s' % ', '.join(msg))[0 < len(msg)] def _check_success_base_response(self, data, endpoint, message='', data_type=dict): # type: (Any, Any, AnyStr, type) -> None r, msg = self._check_types(data, [('result', string_types), ('data', data_type), ('message', string_types)]) self.assertTrue(r, msg='Failed command: %s%s' % (webapi._functionMaper_reversed[endpoint], msg)) self.assertEqual(data['result'], 'success') self.assertEqual(data['message'], message) def _check_episode_data(self, data, endpoint): r, msg = self._check_types( data, [('absolute_number', integer_types), ('airdate', string_types), ('description', string_types), ('name', string_types), ('quality', string_types), ('scene_absolute_number', integer_types), ('scene_episode', integer_types), ('scene_season', integer_types), ('status', string_types), ('timezone', (NoneType, string_types))] ) self.assertTrue(r, msg='Failed command: %s - data episode dict%s' % ( webapi._functionMaper_reversed[endpoint], msg)) def test_sg(self): data = self._request_from_api(webapi.CMD_SickGear) r, msg = self._check_types(data, [('data', dict), ('message', string_types), ('result', string_types)]) self.assertTrue(r, msg='Failed command: %s%s' % (webapi._functionMaper_reversed[webapi.CMD_SickGear], msg)) r, msg = self._check_types(data['data'], [('api_commands', list), ('api_version', integer_types), ('fork', string_types), ('sb_version', string_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGear], msg)) needed_ele = [(k, string_types) for k in iterkeys(webapi._functionMaper) if 'listcommands' != k] r = all(v[0] in data['data']['api_commands'] for v in needed_ele) if not r: i = list(set(n[0] for n in needed_ele) - set(data['data']['api_commands'])) else: i = [] self.assertTrue(r, msg='Failed command: %s - api_commands list%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGear], ('', ', missing: %s' % ','.join(i))[0 < len(i)])) def _check_show_fields(self, data, endpoint, include_season_list=True): r, msg = self._check_types( data, [('air_by_date', integer_types), ('airs', string_types), ('anime', integer_types), ('cache', dict), ('classification', string_types), ('flatten_folders', integer_types), ('genre', list), ('global_exclude_ignore', string_types), ('global_exclude_require', string_types), ('ids', dict), ('ignorewords', string_types), ('imdb_id', string_types), ('indexer', integer_types), ('indexerid', integer_types), ('language', string_types), ('location', string_types), ('network', string_types), ('next_ep_airdate', string_types), ('paused', integer_types), ('prune', integer_types), ('quality', string_types), ('quality_details', dict), ('requirewords', string_types), ('runtime', integer_types), ('scenenumbering', bool), ('show_name', string_types), ('sports', integer_types), ('startyear', integer_types), ('status', string_types), ('subtitles', integer_types), ('tag', string_types), ('timezone', (NoneType, string_types)), ('tvrage_id', integer_types), ('tvrage_name', string_types), ('upgrade_once', integer_types)] + ([], [('season_list', list)])[include_season_list] ) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[endpoint], msg)) r, msg = self._check_types(data['ids'], [('%s' % k, integer_types) for k in sickgear.indexermapper.indexer_list]) self.assertTrue(r, msg='Failed shows "ids" check: %s' % msg) r, msg = self._check_types( data['quality_details'], [('archive', list), ('initial', list)] ) self.assertTrue(r, msg='Failed shows "quality_details" check: %s' % msg) def test_show(self): # test not found data = self._request_from_api(webapi.CMD_SickGearShow, params={'indexer': 1, 'indexerid': 98765}) r, msg = self._check_types(data, [('result', string_types), ('data', dict), ('message', string_types)]) self.assertTrue(r, msg='Failed command: %s%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShow], msg)) self.assertEqual(data['result'], 'failure') self.assertEqual(data['message'], 'Show not found') # test existing show for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShow, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearShow) self._check_show_fields(data['data'], webapi.CMD_SickGearShow) def test_seasons(self): for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShowSeasons, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearShowSeasons) for season, eps in iteritems(cur_show['episodes']): r, msg = self._check_types(data['data'], [('%s' % season, dict)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowSeasons], msg)) for cur_ep in iterkeys(eps): r, msg = self._check_types(data['data']['%s' % season], [('%s' % cur_ep, dict)]) self.assertTrue(r, msg='Failed command: %s - data season dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowSeasons], msg)) self._check_episode_data(data['data']['%s' % season]['%s' % cur_ep], webapi.CMD_SickGearShowSeasons) def test_coming_episodes(self): data = self._request_from_api(webapi.CMD_SickGearComingEpisodes) self._check_success_base_response(data, webapi.CMD_SickGearComingEpisodes) r, msg = self._check_types(data['data'], [('later', list), ('missed', list), ('soon', list), ('today', list)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearComingEpisodes], msg)) self.assertTrue(all(0 < len(data['data'][t]) for t in ('later', 'missed', 'soon', 'today')), msg='Not all categories returned') for t_p in ('later', 'missed', 'soon', 'today'): for cur_ep in data['data'][t_p]: r, msg = self._check_types( cur_ep, [('airdate', string_types), ('airs', string_types), ('data_network', string_types), ('data_show_name', string_types), ('ep_name', string_types), ('ep_plot', string_types), ('episode', integer_types), ('ids', dict), ('local_datetime', string_types), ('network', string_types), ('parsed_datetime', string_types), ('paused', integer_types), ('prod_id', integer_types), ('quality', string_types), ('runtime', integer_types), ('season', integer_types), ('show_name', string_types), ('show_status', string_types), ('status', integer_types), ('status_str', string_types), ('timezone', (NoneType, string_types)), ('tv_id', integer_types), ('tvdbid', integer_types), ('weekday', integer_types)] ) self.assertTrue(r, msg='Failed command: %s - data %s dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearComingEpisodes], t_p, msg)) r, msg = self._check_types(cur_ep['ids'], [('%s' % k, integer_types) for k in sickgear.indexermapper.indexer_list]) self.assertTrue(r, msg='Failed %s "ids" check: %s' % (t_p, msg)) def test_all_shows(self): data = self._request_from_api(webapi.CMD_SickGearShows) self._check_success_base_response(data, webapi.CMD_SickGearShows) for show_id, cur_show in iteritems(data['data']): self._check_show_fields(cur_show, webapi.CMD_SickGearShows, include_season_list=False) def test_episode(self): # not found episode data = self._request_from_api(webapi.CMD_SickGearEpisode, params={'indexer': 1, 'indexerid': 1234, 'season': 10, 'episode': 11}) r, msg = self._check_types(data, [('result', string_types), ('data', dict), ('message', string_types)]) self.assertTrue(r, msg='Failed command: %s%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearEpisode], msg)) self.assertEqual(data['result'], 'error') self.assertEqual(data['message'], 'Episode not found') # found episode for cur_show in test_shows: for season, eps in iteritems(cur_show['episodes']): for cur_ep in iterkeys(eps): data = self._request_from_api(webapi.CMD_SickGearEpisode, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid'], 'season': season, 'episode': cur_ep}) self._check_success_base_response(data, webapi.CMD_SickGearEpisode) r, msg = self._check_types( data['data'], [('absolute_number', integer_types), ('airdate', string_types), ('description', string_types), ('file_size', integer_types), ('file_size_human', string_types), ('location', string_types), ('name', string_types), ('quality', string_types), ('release_name', string_types), ('scene_absolute_number', (NoneType, integer_types)), ('scene_episode', (NoneType, integer_types)), ('scene_season', (NoneType, integer_types)), ('status', string_types), ('subtitles', string_types), ('timezone', (NoneType, string_types))] ) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearEpisode], msg)) def test_shutdown(self): data = self._request_from_api(webapi.CMD_SickGearShutdown) r, msg = self._check_types(data, [('data', dict), ('message', string_types), ('result', string_types)]) self.assertTrue(r, msg='basic test failed for shutdown') self.assertEqual(data['message'], 'SickGear is shutting down...') self.assertEqual(data['result'], 'success') def test_restart(self): data = self._request_from_api(webapi.CMD_SickGearRestart) r, msg = self._check_types(data, [('data', dict), ('message', string_types), ('result', string_types)]) self.assertTrue(r, msg='basic test failed for shutdown') self.assertEqual(data['message'], 'SickGear is restarting...') self.assertEqual(data['result'], 'success') def test_ping(self): data = self._request_from_api(webapi.CMD_SickGearPing) r, msg = self._check_types(data, [('data', dict), ('message', string_types), ('result', string_types)]) self.assertTrue(r, msg='basic test failed for shutdown') self.assertEqual(data['message'], 'Pong') self.assertEqual(data['result'], 'success') def test_get_indexers(self): data = self._request_from_api(webapi.CMD_SickGearGetIndexers) self._check_success_base_response(data, webapi.CMD_SickGearGetIndexers) r, msg = self._check_types(data['data'], [('%s' % k, dict) for k in sickgear.indexermapper.indexer_list]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearGetIndexers], msg)) for i in sickgear.indexermapper.indexer_list: r, msg = self._check_types( data['data']['%s' % i], [('id', integer_types), ('main_url', string_types), ('name', string_types), ('searchable', bool), ('show_url', string_types)]) self.assertTrue(r, msg='Failed command: %s - data %s dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearGetIndexers], i, msg)) def test_get_seasonlist(self): for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShowSeasonList, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearShowSeasonList, data_type=list) r = all(isinstance(v, integer_types) for v in data['data']) self.assertTrue(r, msg='Failed command: %s - data dict incorrect type' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowSeasonList])) def test_get_episodelist(self): for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShowSeasons, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearShowSeasons) r, msg = self._check_types(data['data'], [('%s' % i, dict) for i in iterkeys(cur_show['episodes'])]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowSeasons], msg)) for season, eps in iteritems(cur_show['episodes']): r, msg = self._check_types(data['data'], [('%s' % season, dict)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowSeasons], msg)) for cur_ep in iterkeys(eps): r, msg = self._check_types(data['data']['%s' % season], [('%s' % cur_ep, dict)]) self.assertTrue(r, msg='Failed command: %s - data season dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowSeasons], msg)) self._check_episode_data(data['data']['%s' % season]['%s' % cur_ep], webapi.CMD_SickGearShowSeasons) def test_get_require_words(self): # global data = self._request_from_api(webapi.CMD_SickGearListRequireWords) self._check_success_base_response(data, webapi.CMD_SickGearListRequireWords, message='Global require word list') r, msg = self._check_types(data['data'], [('require words', list), ('type', string_types), ('use regex', bool)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearListRequireWords], msg)) # show based for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearListRequireWords, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearListRequireWords, message='%s: require word list' % cur_show['name']) r, msg = self._check_types( data['data'], [('require words', list), ('type', string_types), ('use regex', bool), ('global exclude require', list), ('indexer', integer_types), ('indexerid', integer_types), ('show name', string_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearListRequireWords], msg)) def test_get_ignore_words(self): # global data = self._request_from_api(webapi.CMD_SickGearListIgnoreWords) self._check_success_base_response(data, webapi.CMD_SickGearListIgnoreWords, message='Global ignore word list') r, msg = self._check_types(data['data'], [('ignore words', list), ('type', string_types), ('use regex', bool)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearListIgnoreWords], msg)) # show based for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearListIgnoreWords, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearListIgnoreWords, message='%s: ignore word list' % cur_show['name']) r, msg = self._check_types( data['data'], [('ignore words', list), ('type', string_types), ('use regex', bool), ('global exclude ignore', list), ('indexer', integer_types), ('indexerid', integer_types), ('show name', string_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearListIgnoreWords], msg)) def test_get_search_queue(self): data = self._request_from_api(webapi.CMD_SickGearSearchQueue) self._check_success_base_response(data, webapi.CMD_SickGearSearchQueue) r, msg = self._check_types( data['data'], [(t, list) for t in ('backlog', 'failed', 'manual', 'proper')] + [('recent', integer_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearSearchQueue], msg)) def test_get_system_default(self): data = self._request_from_api(webapi.CMD_SickGearGetDefaults) self._check_success_base_response(data, webapi.CMD_SickGearGetDefaults) r, msg = self._check_types( data['data'], [('archive', list), ('flatten_folders', integer_types), ('future_show_paused', integer_types), ('initial', list), ('status', string_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearGetDefaults], msg)) def test_get_all_qualities(self): data = self._request_from_api(webapi.CMD_SickGearGetQualities) self._check_success_base_response(data, webapi.CMD_SickGearGetQualities) r, msg = self._check_types(data['data'], [(q, integer_types) for q in iterkeys(webapi.quality_map)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearGetQualities], msg)) def test_get_human_qualities(self): data = self._request_from_api(webapi.CMD_SickGearGetqualityStrings) self._check_success_base_response(data, webapi.CMD_SickGearGetqualityStrings) r, msg = self._check_types(data['data'], [('%s' % q, string_types) for q in iterkeys(Quality.qualityStrings)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearGetqualityStrings], msg)) def test_get_scene_qualities(self): # global data = self._request_from_api(webapi.CMD_SickGearExceptions) self._check_success_base_response(data, webapi.CMD_SickGearExceptions) r = all(isinstance(e, string_types) for e in data['data']) self.assertTrue(r, msg='Failed command: %s - data dict' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearExceptions])) # show specific for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearExceptions, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearExceptions, data_type=list) r = all(isinstance(e, string_types) for e in data['data']) self.assertTrue(r, msg='Failed command: %s - data dict' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearExceptions])) def test_history(self): data = self._request_from_api(webapi.CMD_SickGearHistory) self._check_success_base_response(data, webapi.CMD_SickGearHistory, data_type=list) for cur_show in data['data']: self.assertTrue(isinstance(cur_show, dict), msg='wrong type') r, msg = self._check_types( cur_show, [('date', string_types), ('episode', integer_types), ('indexer', integer_types), ('indexerid', integer_types), ('provider', string_types), ('quality', string_types), ('resource', string_types), ('resource_path', string_types), ('season', integer_types), ('show_name', string_types), ('status', string_types), ('tvdbid', integer_types), ('version', integer_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearHistory], msg)) def test_shows_stats(self): data = self._request_from_api(webapi.CMD_SickGearShowsStats) self._check_success_base_response(data, webapi.CMD_SickGearShowsStats) r, msg = self._check_types( data['data'], [('ep_downloaded', integer_types), ('ep_total', integer_types), ('shows_active', integer_types), ('shows_total', integer_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowsStats], msg)) def test_show_stats(self): for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShowStats, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearShowStats) r, msg = self._check_types( data['data'], [(statusStrings.statusStrings[status].lower().replace(" ", "_").replace("(", "").replace( ")", ""), integer_types) for status in statusStrings.statusStrings if status not in SNATCHED_ANY + [UNKNOWN, DOWNLOADED]] + [('downloaded', dict), ('snatched', dict)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowStats], msg)) for s in ('downloaded', 'snatched'): r, msg = self._check_types( data['data'][s], [(t.lower().replace(" ", "_").replace("(", "").replace(")", ""), integer_types) for k, t in iteritems(Quality.qualityStrings) if Quality.NONE != k]) self.assertTrue(r, msg='Failed command: %s - data dict - %s:%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowStats], s, msg)) def test_get_root_dirs(self): data = self._request_from_api(webapi.CMD_SickGearGetRootDirs) self._check_success_base_response(data, webapi.CMD_SickGearGetRootDirs, data_type=list) for r_d in data['data']: r, msg = self._check_types(r_d, [('default', integer_types), ('location', string_types), ('valid', integer_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearListIgnoreWords], msg)) def test_get_schedules(self): data = self._request_from_api(webapi.CMD_SickGearCheckScheduler) self._check_success_base_response(data, webapi.CMD_SickGearCheckScheduler) r, msg = self._check_types( data['data'], [('backlog_is_paused', integer_types), ('backlog_is_running', integer_types), ('last_backlog', string_types), ('next_backlog', string_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearCheckScheduler], msg)) def test_do_show_update(self): for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShowUpdate, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearShowUpdate, message='%s has queued to be updated' % cur_show['name']) # check that duplicate adding fails for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShowUpdate, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) r, msg = self._check_types(data, [('data', dict), ('message', string_types), ('result', string_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowUpdate], msg)) self.assertTrue('Unable to update %s.' % cur_show['name'] in data['message'], msg='Wrong failure message') def test_do_show_refresh(self): for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShowRefresh, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) self._check_success_base_response(data, webapi.CMD_SickGearShowUpdate, message='%s has queued to be refreshed' % cur_show['name']) # check that duplicate adding fails for cur_show in test_shows: data = self._request_from_api(webapi.CMD_SickGearShowRefresh, params={'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']}) r, msg = self._check_types(data, [('data', dict), ('message', string_types), ('result', string_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearShowRefresh], msg)) self.assertTrue('Unable to refresh %s.' % cur_show['name'] in data['message'], msg='Wrong failure message') def test_pause_show(self): self.reset_show_data = True self.show_save_db = sickgear.tv.TVShow.save_to_db sickgear.tv.TVShow.save_to_db = fake_action for set_pause in (None, 0, 1, 0): for cur_show in test_shows: params = {'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']} if None is not set_pause: params.update({'pause': set_pause}) data = self._request_from_api(webapi.CMD_SickGearShowPause, params=params) self._check_success_base_response(data, webapi.CMD_SickGearShowPause, message='%s has been %spaused' % ( cur_show['name'], ('', 'un')[set_pause in (None, 0, False)])) def test_set_scene_numbering(self): self.reset_show_data = True self.show_save_db = sickgear.tv.TVShow.save_to_db sickgear.tv.TVShow.save_to_db = fake_action for set_scene in (1, 0): for cur_show in test_shows: params = {'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']} if None is not set_scene: params.update({'activate': set_scene}) data = self._request_from_api(webapi.CMD_SickGearActivateSceneNumber, params=params) self._check_success_base_response(data, webapi.CMD_SickGearActivateSceneNumber, message='Scene Numbering %sactivated' % ( ('', 'de')[set_scene in (None, 0, False)])) r, msg = self._check_types( data['data'], [('indexer', integer_types), ('indexerid', integer_types), ('scenenumbering', bool), ('show_name', string_types)]) self.assertTrue(r, msg='Failed command: %s - data dict%s' % ( webapi._functionMaper_reversed[webapi.CMD_SickGearActivateSceneNumber], msg)) self.assertTrue(data['data']['scenenumbering'] == bool(set_scene)) self.assertTrue(data['data']['show_name'] == cur_show['name']) def test_set_show_quality(self): self.reset_show_data = True self.show_save_db = sickgear.tv.TVShow.save_to_db sickgear.tv.TVShow.save_to_db = fake_action for set_quality in [ {'init': [Quality.SDTV], 'upgrade': [], 'upgrade_once': 0}, {'init': [Quality.SDTV], 'upgrade': [], 'upgrade_once': 1}, {'init': [Quality.SDTV], 'upgrade': [Quality.FULLHDWEBDL, Quality.FULLHDBLURAY], 'upgrade_once': 0}, {'init': [Quality.SDTV], 'upgrade': [Quality.FULLHDWEBDL, Quality.FULLHDBLURAY], 'upgrade_once': 1}, {'init': [Quality.SDTV, Quality.SDDVD, Quality.HDTV], 'upgrade': [], 'upgrade_once': 0}, {'init': [Quality.SDTV, Quality.SDDVD, Quality.HDTV], 'upgrade': [], 'upgrade_once': 1}, {'init': [Quality.SDTV, Quality.SDDVD, Quality.HDTV], 'upgrade': [Quality.SDDVD, Quality.HDWEBDL], 'upgrade_once': 0}, {'init': [Quality.SDTV, Quality.SDDVD, Quality.HDTV], 'upgrade': [Quality.SDDVD, Quality.HDWEBDL], 'upgrade_once': 1}, ]: for cur_show in test_shows: show_obj = sickgear.helpers.find_show_by_id({cur_show['tvid']: cur_show['prodid']}) params = {'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']} for t in ('init', 'upgrade', 'upgrade_once'): if set_quality[t]: params.update({t: set_quality[t]}) data = self._request_from_api(webapi.CMD_SickGearShowSetQuality, params=params) self._check_success_base_response( data, webapi.CMD_SickGearShowSetQuality, message='%s quality has been changed to %s' % ( cur_show['name'], webapi._get_quality_string(show_obj.quality))) self.assertEqual(show_obj.upgrade_once, int(set_quality['upgrade_once'])) def test_set_show_scene_numbers(self): self.reset_show_data = True self.show_save_db = sickgear.tv.TVShow.save_to_db sickgear.tv.TVShow.save_to_db = fake_action for set_numbers in [ {'forSeason': 1, 'forEpisode': 1, 'forAbsolute': None, 'sceneSeason': 1, 'sceneEpisode': 2, 'sceneAbsolute': None, }, ]: for cur_show in test_shows: params = {'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid']} set_scene_params = params.copy() set_scene_params.update({'activate': 1}) data = self._request_from_api(webapi.CMD_SickGearActivateSceneNumber, params=set_scene_params) self._check_success_base_response(data, webapi.CMD_SickGearActivateSceneNumber, message='Scene Numbering activated') for t in ('forSeason', 'forEpisode', 'forAbsolute', 'sceneSeason', 'sceneEpisode', 'sceneAbsolute'): if set_numbers[t]: params.update({t: set_numbers[t]}) data = self._request_from_api(webapi.CMD_SickGearSetSceneNumber, params=params) self._check_success_base_response(data, webapi.CMD_SickGearSetSceneNumber) self._check_types( data['data'], [(t, integer_types) for t in ('forSeason', 'forEpisode', 'sceneSeason', 'sceneEpisode')] + [('success', bool)]) for t in ('forSeason', 'forEpisode', 'sceneSeason', 'sceneEpisode'): self.assertEqual(data['data'][t], set_numbers[t]) def test_set_episode_status(self): self.org_mass_action = db.DBConnection.mass_action db.DBConnection.mass_action = fake_action self.reset_show_data = True failed_msg = 'Failed to set all or some status. Check data.' success_msg = 'All status set successfully.' for cur_quality_str, cur_quality in itertools.chain(iteritems(webapi.quality_map), iteritems({'None': None})): for cur_value, cur_status in iteritems(statusStrings.statusStrings): if (cur_quality and cur_value not in (SNATCHED, DOWNLOADED, ARCHIVED)) or \ (None is cur_quality and SNATCHED == cur_value): continue cur_status = cur_status.lower() # print('Testing setting episode status to: %s %s' % (cur_status, cur_quality_str)) if cur_value in (UNKNOWN, UNAIRED, SNATCHED_PROPER, SNATCHED_BEST, SUBTITLED): continue for cur_show in test_shows: for season, eps in iteritems(cur_show['episodes']): for ep_nb, cur_ep in iteritems(eps): ep_obj = sickgear.helpers.find_show_by_id({cur_show['tvid']: cur_show['prodid']}).\ get_episode(season, ep_nb) params = {'indexer': cur_show['tvid'], 'indexerid': cur_show['prodid'], 'season': season, 'episode': ep_nb, 'status': cur_status} if cur_quality: params.update({'quality': cur_quality_str}) old_status = ep_obj.status status, quality = Quality.split_composite_status(ep_obj.status) expect_fail = UNAIRED == status or (DOWNLOADED == status and not cur_quality) expected_msg = (success_msg, failed_msg)[expect_fail] data = self._request_from_api(webapi.CMD_SickGearEpisodeSetStatus, params=params) r, msg = self._check_types(data, [('result', string_types), ('data', (dict, list)[expect_fail]), ('message', string_types)]) self.assertTrue(r, msg=msg) self.assertTrue(data['message'].startswith(expected_msg)) # reset status ep_obj.status = old_status # ep_obj.save_to_db() if __name__ == '__main__': print('==================') print('STARTING - WebAPI TESTS') print('==================') print('######################################################################') suite = unittest.TestLoader().loadTestsFromTestCase(WebAPICase) unittest.TextTestRunner(verbosity=2).run(suite)