def test_check_notifier_not_found(self):
notifiers_manager = NotifierManager({'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.send_test_message = MagicMock(side_effect=KeyError)
notifier = NotifierCheck(notifiers_manager)
notifier.__no_auth__ = True
self.api.add_route('/api/clients/{notifier}/check', notifier)
self.simulate_request('/api/clients/{0}/check'.format('tracker.org'))
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
def test_failed_update_settings(self):
notifiers_manager = NotifierManager({'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.update_settings = MagicMock(return_value=False)
notifier = Notifier(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}', notifier)
self.simulate_request('/api/notifiers/{0}'.format(1), method="PUT",
body=json.dumps({'login': '******', 'password': '******'}))
self.assertEqual(self.srmock.status, falcon.HTTP_BAD_REQUEST)
def test_not_found_update_settings(self):
notifiers_manager = NotifierManager({'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.update_settings = MagicMock(side_effect=KeyError)
notifier = Notifier(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}', notifier)
self.simulate_request('/api/notifiers/{0}'.format(1), method="PUT",
body=json.dumps({'login': '******', 'password': '******'}))
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
def test_failed_update_settings(self):
# noinspection PyTypeChecker
notifiers_manager = NotifierManager(Mock(), {'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.update_settings = Mock(return_value=False)
notifier = Notifier(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}', notifier)
self.simulate_request('/api/notifiers/{0}'.format(1), method="PUT",
body=json.dumps({'login': '******', 'password': '******'}))
self.assertEqual(self.srmock.status, falcon.HTTP_BAD_REQUEST)
def test_check_notifier_not_found(self):
notifiers_manager = NotifierManager(
{'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.send_test_message = MagicMock(side_effect=KeyError)
notifier = NotifierCheck(notifiers_manager)
notifier.__no_auth__ = True
self.api.add_route('/api/clients/{notifier}/check', notifier)
self.simulate_request('/api/clients/{0}/check'.format('tracker.org'))
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
def test_not_found_settings(self):
notifiers_manager = NotifierManager({'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.get_settings = MagicMock(side_effect=KeyError)
notifier = Notifier(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}', notifier)
self.simulate_request('/api/notifiers/{0}'.format(1))
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
self.assertTrue('application/json' in self.srmock.headers_dict['Content-Type'])
def test_not_found_update_settings(self):
# noinspection PyTypeChecker
notifiers_manager = NotifierManager(Mock(), {'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.update_settings = Mock(side_effect=KeyError)
notifier = Notifier(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}', notifier)
self.simulate_request('/api/notifiers/{0}'.format(1), method="PUT",
body=json.dumps({'login': '******', 'password': '******'}))
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
def test_check_notifier_failed(self):
# noinspection PyTypeChecker
notifiers_manager = NotifierManager(
Mock(), {'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.send_test_message = Mock(side_effect=Exception)
notifier = NotifierCheck(notifiers_manager)
notifier.__no_auth__ = True
self.api.add_route('/api/clients/{notifier}/check', notifier)
self.simulate_request('/api/clients/{0}/check'.format('tracker.org'))
self.assertEqual(self.srmock.status, falcon.HTTP_INTERNAL_SERVER_ERROR)
def setUp(self):
super(NotifierManagerTest, self).setUp()
self.notifier1 = Mock()
self.notifier2 = Mock()
self.notifier_manager = NotifierManager({
self.NOTIFIER1_NAME:
self.notifier1,
self.NOTIFIER2_NAME:
self.notifier2
})
def test_not_found_settings(self):
# noinspection PyTypeChecker
notifiers_manager = NotifierManager(Mock(), {'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.get_settings = Mock(side_effect=KeyError)
notifier = Notifier(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}', notifier)
self.simulate_request('/api/notifiers/{0}'.format(1))
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
self.assertTrue('application/json' in self.srmock.headers_dict['Content-Type'])
def setUp(self):
super(NotifierManagerTest, self).setUp()
self.settings_manager = Mock()
self.notifier1 = Mock()
self.notifier2 = Mock()
# noinspection PyTypeChecker
self.notifier_manager = NotifierManager(self.settings_manager, {
NOTIFIER1_NAME: self.notifier1,
NOTIFIER2_NAME: self.notifier2
})
def test_successful_update_settings(self):
notifiers_manager = NotifierManager(
{'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.update_settings = MagicMock(return_value=True)
notifier = Notifier(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}', notifier)
self.simulate_request('/api/notifiers/{0}'.format('test'),
method="PUT",
body=json.dumps({
'login': '******',
'password': '******'
}))
self.assertEqual(self.srmock.status, falcon.HTTP_NO_CONTENT)
def test_check_notifier(self, value):
notifier_manager = NotifierManager({'test': NotifierCollectionTest.TestNotifier()})
notifier_manager.send_test_message = MagicMock(return_value=value)
notifier = NotifierCheck(notifier_manager)
notifier.__no_auth__ = True
self.api.add_route('/api/notifiers/{notifier}/check', notifier)
body = self.simulate_request('/api/notifiers/{0}/check'.format('tracker.org'), decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
self.assertTrue('application/json' in self.srmock.headers_dict['Content-Type'])
result = json.loads(body)
self.assertIsInstance(result, dict)
self.assertEqual(result, {'status': value})
def test_empty_get_settings(self):
notifiers_manager = NotifierManager({'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.get_settings = MagicMock(return_value=None)
notifier = Notifier(notifiers_manager)
notifier.__no_auth__ = True
self.api.add_route('/api/notifiers/{notifier}', notifier)
body = self.simulate_request('/api/notifiers/{0}'.format(1), decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
self.assertTrue('application/json' in self.srmock.headers_dict['Content-Type'])
result = json.loads(body)
self.assertIsInstance(result, dict)
self.assertEqual(result, {})
def test_get_all(self):
# noinspection PyTypeChecker
notifiers_manager = NotifierManager(
Mock(), {'test': NotifierCollectionTest.TestNotifier()})
notifier_collection = NotifierCollection(notifiers_manager)
self.api.add_route('/api/notifiers', notifier_collection)
body = self.simulate_request('/api/notifiers', decode='utf-8')
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
self.assertTrue(
'application/json' in self.srmock.headers_dict['Content-Type'])
result = json.loads(body)
self.assertIsInstance(result, list)
self.assertEqual(1, len(result))
self.assertEqual(
result[0], {
'name': 'test',
'form': NotifierCollectionTest.TestNotifier.form,
'has_settings': True,
'enabled': True
})
def create_runner(self, logger=None):
self.settings_manager = Mock()
self.clients_manager = ClientsManager({})
self.notifier_manager = NotifierManager(self.settings_manager, {})
# noinspection PyTypeChecker
self.engine_runner = DBEngineRunner(
Logger() if logger is None else logger, self.settings_manager,
self.trackers_manager, self.clients_manager, self.notifier_manager)
def test_empty_get_settings(self):
# noinspection PyTypeChecker
notifiers_manager = NotifierManager(Mock(), {'test': NotifierCollectionTest.TestNotifier()})
notifiers_manager.get_settings = Mock(return_value=None)
notifier = Notifier(notifiers_manager)
notifier.__no_auth__ = True
self.api.add_route('/api/notifiers/{notifier}', notifier)
body = self.simulate_request('/api/notifiers/{0}'.format(1), decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
self.assertTrue('application/json' in self.srmock.headers_dict['Content-Type'])
result = json.loads(body)
self.assertIsInstance(result, dict)
self.assertEqual(result, {})
def setUp(self):
super(NotifierManagerTest, self).setUp()
self.notifier1 = Mock()
self.notifier2 = Mock()
self.notifier_manager = NotifierManager(
{self.NOTIFIER1_NAME: self.notifier1, self.NOTIFIER2_NAME: self.notifier2})
def test_check_notifier(self, value):
# noinspection PyTypeChecker
notifier_manager = NotifierManager(Mock(), {'test': NotifierCollectionTest.TestNotifier()})
notifier_manager.send_test_message = Mock(return_value=value)
notifier = NotifierCheck(notifier_manager)
notifier.__no_auth__ = True
self.api.add_route('/api/notifiers/{notifier}/check', notifier)
body = self.simulate_request('/api/notifiers/{0}/check'.format('tracker.org'), decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
self.assertTrue('application/json' in self.srmock.headers_dict['Content-Type'])
result = json.loads(body)
self.assertIsInstance(result, dict)
self.assertEqual(result, {'status': value})
def test_get_settings(self):
notifier_manager = NotifierManager(
{'test': NotifierCollectionTest.TestNotifier()})
settings = BaseNotifier()
settings.login = '******'
notifier_manager.get_settings = MagicMock(return_value=settings)
notifier = Notifier(notifier_manager)
self.api.add_route('/api/notifiers/{notifier}', notifier)
body = self.simulate_request('/api/notifiers/{0}'.format(1),
decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
self.assertTrue(
'application/json' in self.srmock.headers_dict['Content-Type'])
result = json.loads(body)
self.assertIsInstance(result, dict)
self.assertEqual(result['login'], settings.login)
def create_runner(self, logger=None, interval=0.1):
self.settings_manager = Mock()
self.clients_manager = ClientsManager({})
self.notifier_manager = NotifierManager(self.settings_manager, {})
self.engine_runner = EngineRunner(
Logger() if logger is None else logger,
self.settings_manager,
self.trackers_manager,
self.clients_manager,
self.notifier_manager,
interval=interval)
def setUp(self):
super(NotifierManagerNotificationsTest, self).setUp()
levels = ['DOWNLOAD', 'ERROR', 'STATUS_CHANGED']
self.settings_manager = Mock()
self.settings_manager.get_external_notifications_levels = Mock(
return_value=levels)
self.settings1 = Notifier1Settings()
self.settings1.is_enabled = True
self.settings1.type = NOTIFIER1_NAME
self.settings2 = Notifier2Settings()
self.settings2.is_enabled = False
self.settings2.type = NOTIFIER2_NAME
self.settings3 = Notifier3Settings()
self.settings3.is_enabled = True
self.settings3.type = NOTIFIER3_NAME
with DBSession() as db:
db.add(self.settings1)
db.add(self.settings2)
db.add(self.settings3)
self.notifier1 = MagicMock()
self.notifier1.get_type = NotifierType.short_text
self.notifier2 = MagicMock()
self.notifier2.get_type = NotifierType.short_text
self.notifier3 = MagicMock()
self.notifier3.get_type = NotifierType.full_text
# noinspection PyTypeChecker
self.notifier_manager = NotifierManager(
self.settings_manager, {
NOTIFIER1_NAME: self.notifier1,
NOTIFIER2_NAME: self.notifier2,
NOTIFIER3_NAME: self.notifier3
})
def test_set_enabled_error_updating(self):
test_notifier = NotifierCollectionTest.TestNotifier()
# noinspection PyTypeChecker
notifiers_manager = NotifierManager(Mock(), {'test': test_notifier})
settings = Mock()
test_notifier.get_settings = Mock(return_value=settings)
type(test_notifier).is_enabled = PropertyMock(side_effect=Exception)
notifier_enabled = NotifierEnabled(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}/enabled', notifier_enabled)
self.simulate_request('/api/notifiers/{0}/enabled'.format('test'), method="PUT",
body=json.dumps({'enabled': True}))
self.assertEqual(self.srmock.status, falcon.HTTP_400)
def test_set_enabled_invalid_key(self):
test_notifier = NotifierCollectionTest.TestNotifier()
# noinspection PyTypeChecker
notifiers_manager = NotifierManager(Mock(), {'test': test_notifier})
settings = Mock()
test_notifier.get_settings = Mock(return_value=settings)
test_notifier.update_settings = Mock()
notifier_enabled = NotifierEnabled(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}/enabled', notifier_enabled)
self.simulate_request('/api/notifiers/{0}/enabled'.format('blabla'), method="PUT",
body=json.dumps({'enabled': True}))
self.assertEqual(self.srmock.status, falcon.HTTP_404)
def test_set_enabled_error_updating(self):
test_notifier = NotifierCollectionTest.TestNotifier()
notifiers_manager = NotifierManager({'test': test_notifier})
settings = MagicMock()
test_notifier.get_settings = MagicMock(return_value=settings)
test_notifier.update_settings = MagicMock(return_value=False)
notifier_enabled = NotifierEnabled(notifiers_manager)
self.api.add_route('/api/notifiers/{notifier}/enabled',
notifier_enabled)
body = self.simulate_request(
'/api/notifiers/{0}/enabled'.format('test'),
method="PUT",
body=json.dumps({'is_enabled': True}))
self.assertEqual(self.srmock.status, falcon.HTTP_400)
def setUp(self):
super(EngineTest, self).setUp()
self.log_mock = Logger()
self.log_info_mock = MagicMock()
self.log_downloaded_mock = MagicMock()
self.log_failed_mock = MagicMock()
self.log_mock.info = self.log_info_mock
self.log_mock.downloaded = self.log_downloaded_mock
self.log_mock.failed = self.log_failed_mock
self.clients_manager = ClientsManager()
self.settings_manager = Mock()
self.trackers_manager = TrackersManager(self.settings_manager, {})
self.notifier_manager = NotifierManager({})
self.engine = Engine(self.log_mock, self.settings_manager,
self.trackers_manager, self.clients_manager,
self.notifier_manager)
def main():
def try_int(s, base=10, val=None):
if s is None:
return None
try:
return int(s, base)
except ValueError:
return val
class Config(object):
debug = False
ip = '0.0.0.0'
port = 6687
db_path = 'monitorrent.db'
config = 'config.py'
def __init__(self, parsed_args):
if parsed_args.config is not None and not os.path.isfile(parsed_args.config):
warnings.warn('File not found: {}'.format(parsed_args.config))
config_path = parsed_args.config or self.config
if os.path.isfile(config_path):
# noinspection PyBroadException
try:
parsed_config = {}
with open(config_path) as config_file:
six.exec_(compile(config_file.read(), config_path, 'exec'), {}, parsed_config)
self.debug = parsed_config.get('debug', self.debug)
self.ip = parsed_config.get('ip', self.ip)
self.port = parsed_config.get('port', self.port)
self.db_path = parsed_config.get('db_path', self.db_path)
except:
ex, val, tb = sys.exc_info()
warnings.warn('Error reading: {0}: {1} ({2}'.format(parsed_args.config, ex, val))
env_debug = (os.environ.get('MONITORRENT_DEBUG', None) in ['true', 'True', '1'])
self.debug = parsed_args.debug or env_debug or self.debug
self.ip = parsed_args.ip or os.environ.get('MONITORRENT_IP', None) or self.ip
self.port = parsed_args.port or try_int(os.environ.get('MONITORRENT_PORT', None)) or self.port
self.db_path = parsed_args.db_path or os.environ.get('MONITORRENT_DB_PATH', None) or self.db_path
parser = argparse.ArgumentParser(description='Monitorrent server')
parser.add_argument('--debug', action='store_true',
help='Run in debug mode. Secret key is always the same.')
parser.add_argument('--ip', type=str, dest='ip',
help='Bind interface. Default is {0}'.format(Config.ip))
parser.add_argument('--port', type=int, dest='port',
help='Port for server. Default is {0}'.format(Config.port))
parser.add_argument('--db-path', type=str, dest='db_path',
help='Path to SQL lite database. Default is to {0}'.format(Config.db_path))
parser.add_argument('--config', type=str, dest='config',
default=os.environ.get('MONITORRENT_CONFIG', None),
help='Path to config file (default {0})'.format(Config.config))
parsed_args = parser.parse_args()
config = Config(parsed_args)
db_connection_string = "sqlite:///" + config.db_path
init_db_engine(db_connection_string, False)
load_plugins()
upgrade()
create_db()
settings_manager = SettingsManager()
tracker_manager = TrackersManager(settings_manager, get_plugins('tracker'))
clients_manager = DbClientsManager(settings_manager, get_plugins('client'))
notifier_manager = NotifierManager(settings_manager, get_plugins('notifier'))
log_manager = ExecuteLogManager()
engine_runner_logger = DbLoggerWrapper(log_manager, settings_manager)
engine_runner = DBEngineRunner(engine_runner_logger, settings_manager, tracker_manager,
clients_manager, notifier_manager)
include_prerelease = settings_manager.get_new_version_check_include_prerelease()
new_version_checker = NewVersionChecker(notifier_manager, include_prerelease)
if settings_manager.get_is_new_version_checker_enabled():
# noinspection PyBroadException
try:
new_version_checker.execute()
except:
pass
new_version_checker.start(settings_manager.new_version_check_interval)
debug = config.debug
if debug:
secret_key = 'Secret!'
token = 'monitorrent'
else:
secret_key = os.urandom(24)
token = ''.join(random.choice(string.ascii_letters) for _ in range(8))
app = create_app(secret_key, token, tracker_manager, clients_manager, notifier_manager, settings_manager,
engine_runner, log_manager, new_version_checker)
server_start_params = (config.ip, config.port)
server = wsgi.Server(server_start_params, app)
print('Server started on {0}:{1}'.format(*server_start_params))
try:
server.start()
except KeyboardInterrupt:
engine_runner.stop()
server.stop()
class NotifierManagerTest(TestCase):
NOTIFIER1_NAME = 'notifier1'
NOTIFIER2_NAME = 'notifier2'
def setUp(self):
super(NotifierManagerTest, self).setUp()
self.notifier1 = Mock()
self.notifier2 = Mock()
self.notifier_manager = NotifierManager({
self.NOTIFIER1_NAME:
self.notifier1,
self.NOTIFIER2_NAME:
self.notifier2
})
def test_init(self):
notifier_manager = NotifierManager()
self.assertIsNotNone(notifier_manager.notifiers)
def test_get_settings(self):
settings1 = {'uri': 'uri1', 'login': '******', 'password': '******'}
settings2 = {'uri': 'uri2', 'login': '******', 'password': '******'}
self.notifier1.get_settings = MagicMock(return_value=settings1)
self.notifier2.get_settings = MagicMock(return_value=settings2)
settings = self.notifier_manager.get_settings(self.NOTIFIER1_NAME)
self.assertEqual(settings1, settings)
self.notifier1.get_settings.assert_called_with()
self.notifier2.get_settings.assert_not_called()
settings = self.notifier_manager.get_settings(self.NOTIFIER2_NAME)
self.assertEqual(settings2, settings)
self.notifier2.get_settings.assert_called_with()
def test_get_notifier(self):
notifier = self.notifier_manager.get_notifier(
self.NOTIFIER1_NAME).get('notifier')
self.assertEqual(self.notifier1, notifier)
notifier = self.notifier_manager.get_notifier(
self.NOTIFIER2_NAME).get('notifier')
self.assertEqual(self.notifier2, notifier)
def test_update_settings(self):
settings1 = {'uri': 'uri1', 'login': '******', 'password': '******'}
settings2 = {'uri': 'uri2', 'login': '******', 'password': '******'}
self.notifier1.update_settings = MagicMock()
self.notifier2.update_settings = MagicMock()
self.notifier_manager.update_settings(self.NOTIFIER1_NAME, settings1)
self.notifier1.update_settings.assert_called_with(settings1)
self.notifier2.update_settings.assert_not_called()
self.notifier_manager.update_settings(self.NOTIFIER2_NAME, settings2)
self.notifier2.update_settings.assert_called_with(settings2)
def test_send_test_message(self):
notify1 = MagicMock()
notify2 = MagicMock()
self.notifier1.notify = notify1
self.notifier2.notify = notify2
self.notifier_manager.send_test_message(self.NOTIFIER1_NAME)
notify1.assert_called_once_with(
"Test Message", "This is monitorrent test message",
"https://github.com/werwolfby/monitorrent")
notify2.assert_not_called()
self.notifier_manager.send_test_message(self.NOTIFIER2_NAME)
notify2.assert_called_once_with(
"Test Message", "This is monitorrent test message",
"https://github.com/werwolfby/monitorrent")
def test_get_enabled_new_settings(self):
# new should be false
self.notifier1.get_settings = MagicMock(return_value=None)
self.assertFalse(self.notifier_manager.get_enabled(
self.NOTIFIER1_NAME))
def test_set_enabled(self):
self.notifier_manager.set_enabled(self.NOTIFIER1_NAME, True)
self.assertTrue(self.notifier_manager.get_enabled(self.NOTIFIER1_NAME))
self.notifier_manager.set_enabled(self.NOTIFIER1_NAME, False)
self.assertFalse(self.notifier_manager.get_enabled(
self.NOTIFIER1_NAME))
def test_set_enabled_new(self):
self.notifier1.get_settings = MagicMock(return_value=None)
self.notifier1.settings_class = MagicMock
self.notifier_manager.set_enabled(self.NOTIFIER1_NAME, True)
def test_init(self):
notifier_manager = NotifierManager()
self.assertIsNotNone(notifier_manager.notifiers)
class NotifierManagerTest(TestCase):
NOTIFIER1_NAME = 'notifier1'
NOTIFIER2_NAME = 'notifier2'
def setUp(self):
super(NotifierManagerTest, self).setUp()
self.notifier1 = Mock()
self.notifier2 = Mock()
self.notifier_manager = NotifierManager(
{self.NOTIFIER1_NAME: self.notifier1, self.NOTIFIER2_NAME: self.notifier2})
def test_init(self):
notifier_manager = NotifierManager()
self.assertIsNotNone(notifier_manager.notifiers)
def test_get_settings(self):
settings1 = {'uri': 'uri1', 'login': '******', 'password': '******'}
settings2 = {'uri': 'uri2', 'login': '******', 'password': '******'}
self.notifier1.get_settings = MagicMock(return_value=settings1)
self.notifier2.get_settings = MagicMock(return_value=settings2)
settings = self.notifier_manager.get_settings(self.NOTIFIER1_NAME)
self.assertEqual(settings1, settings)
self.notifier1.get_settings.assert_called_with()
self.notifier2.get_settings.assert_not_called()
settings = self.notifier_manager.get_settings(self.NOTIFIER2_NAME)
self.assertEqual(settings2, settings)
self.notifier2.get_settings.assert_called_with()
def test_get_notifier(self):
notifier = self.notifier_manager.get_notifier(self.NOTIFIER1_NAME).get('notifier')
self.assertEqual(self.notifier1, notifier)
notifier = self.notifier_manager.get_notifier(self.NOTIFIER2_NAME).get('notifier')
self.assertEqual(self.notifier2, notifier)
def test_update_settings(self):
settings1 = {'uri': 'uri1', 'login': '******', 'password': '******'}
settings2 = {'uri': 'uri2', 'login': '******', 'password': '******'}
self.notifier1.update_settings = MagicMock()
self.notifier2.update_settings = MagicMock()
self.notifier_manager.update_settings(self.NOTIFIER1_NAME, settings1)
self.notifier1.update_settings.assert_called_with(settings1)
self.notifier2.update_settings.assert_not_called()
self.notifier_manager.update_settings(self.NOTIFIER2_NAME, settings2)
self.notifier2.update_settings.assert_called_with(settings2)
def test_send_test_message(self):
notify1 = MagicMock()
notify2 = MagicMock()
self.notifier1.notify = notify1
self.notifier2.notify = notify2
self.notifier_manager.send_test_message(self.NOTIFIER1_NAME)
notify1.assert_called_once_with("Test Message", "This is monitorrent test message",
"https://github.com/werwolfby/monitorrent")
notify2.assert_not_called()
self.notifier_manager.send_test_message(self.NOTIFIER2_NAME)
notify2.assert_called_once_with("Test Message", "This is monitorrent test message",
"https://github.com/werwolfby/monitorrent")
def test_get_enabled_new_settings(self):
# new should be false
self.notifier1.get_settings = MagicMock(return_value=None)
self.assertFalse(self.notifier_manager.get_enabled(self.NOTIFIER1_NAME))
def test_set_enabled(self):
self.notifier_manager.set_enabled(self.NOTIFIER1_NAME, True)
self.assertTrue(self.notifier_manager.get_enabled(self.NOTIFIER1_NAME))
self.notifier_manager.set_enabled(self.NOTIFIER1_NAME, False)
self.assertFalse(self.notifier_manager.get_enabled(self.NOTIFIER1_NAME))
def test_set_enabled_new(self):
self.notifier1.get_settings = MagicMock(return_value=None)
self.notifier1.settings_class = MagicMock
self.notifier_manager.set_enabled(self.NOTIFIER1_NAME, True)
class NotifierManagerNotificationsTest(DbTestCase):
def setUp(self):
super(NotifierManagerNotificationsTest, self).setUp()
levels = ['DOWNLOAD', 'ERROR', 'STATUS_CHANGED']
self.settings_manager = Mock()
self.settings_manager.get_external_notifications_levels = Mock(
return_value=levels)
self.settings1 = Notifier1Settings()
self.settings1.is_enabled = True
self.settings1.type = NOTIFIER1_NAME
self.settings2 = Notifier2Settings()
self.settings2.is_enabled = False
self.settings2.type = NOTIFIER2_NAME
self.settings3 = Notifier3Settings()
self.settings3.is_enabled = True
self.settings3.type = NOTIFIER3_NAME
with DBSession() as db:
db.add(self.settings1)
db.add(self.settings2)
db.add(self.settings3)
self.notifier1 = MagicMock()
self.notifier1.get_type = NotifierType.short_text
self.notifier2 = MagicMock()
self.notifier2.get_type = NotifierType.short_text
self.notifier3 = MagicMock()
self.notifier3.get_type = NotifierType.full_text
# noinspection PyTypeChecker
self.notifier_manager = NotifierManager(
self.settings_manager, {
NOTIFIER1_NAME: self.notifier1,
NOTIFIER2_NAME: self.notifier2,
NOTIFIER3_NAME: self.notifier3
})
def test_get_enabled_notifiers(self):
enabled = list(self.notifier_manager.get_enabled_notifiers())
self.assertEqual(2, len(enabled))
self.assertEqual(self.notifier1, enabled[0])
self.assertEqual(self.notifier3, enabled[1])
def test_short_text_notify_failed(self):
self.notifier1.notify = Mock(side_effect=Exception)
message = "TestMessage"
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify(message)
self.notifier1.notify.assert_called_once_with("Monitorrent Update",
message)
self.notifier2.notify.assert_not_called()
# should be replaced by contains message instead of full string compare
self.notifier3.notify.assert_called_once_with(
"Monitorrent Update", "Monitorrent execute result\n" + message)
def test_full_text_notify_failed(self):
self.notifier3.notify = Mock(side_effect=Exception)
message = "TestMessage"
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify(message)
self.notifier1.notify.assert_called_once_with("Monitorrent Update",
message)
self.notifier2.notify.assert_not_called()
# should be replaced by contains message instead of full string compare
self.notifier3.notify.assert_called_once_with(
"Monitorrent Update", "Monitorrent execute result\n" + message)
def test_end_execute_not_called(self):
with self.notifier_manager.execute():
pass
self.notifier1.notify.assert_not_called()
self.notifier2.notify.assert_not_called()
self.notifier3.notify.assert_not_called()
def test_end_execute_called(self):
message = "Some message"
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify(message)
self.notifier1.notify.assert_called_once_with("Monitorrent Update",
message)
self.notifier2.notify.assert_not_called()
# should be replaced by contains message instead of full string compare
self.notifier3.notify.assert_called_once_with(
"Monitorrent Update", "Monitorrent execute result\n" + message)
def test_notify_few_times(self):
p1 = PropertyMock(return_value=NotifierType.short_text)
type(self.notifier1).get_type = p1
p2 = PropertyMock(return_value=NotifierType.full_text)
type(self.notifier2).get_type = p2
message1 = "Test message 1"
message2 = "Test message 2"
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify(message1)
notifier_execute.notify(message2)
self.notifier1.notify.assert_has_calls([
call("Monitorrent Update", message1),
call("Monitorrent Update", message2)
])
self.notifier2.notify.assert_not_called()
self.notifier3.notify.assert_called_once_with(
"Monitorrent Update",
"Monitorrent execute result\n" + message1 + "\n" + message2)
def test_disabled_notify_failed(self):
p1 = PropertyMock(return_value=NotifierType.short_text)
type(self.notifier1).get_type = p1
p2 = PropertyMock(return_value=NotifierType.full_text)
type(self.notifier2).get_type = p2
message1 = "Test message 1"
message2 = "Test message 2"
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify_failed(message1)
notifier_execute.notify_failed(message2)
self.notifier1.notify.assert_has_calls([
call("Monitorrent Update", message1),
call("Monitorrent Update", message2)
])
self.notifier2.notify.assert_not_called()
self.notifier3.notify.assert_called_once_with(
"Monitorrent Update",
"Monitorrent execute result\n" + message1 + "\n" + message2)
levels = ['DOWNLOAD', 'STATUS_CHANGED']
self.settings_manager.get_external_notifications_levels = Mock(
return_value=levels)
self.notifier1.notify.reset_mock()
self.notifier2.notify.reset_mock()
self.notifier3.notify.reset_mock()
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify_failed(message1)
notifier_execute.notify_failed(message2)
self.notifier1.notify.assert_not_called()
self.notifier2.notify.assert_not_called()
self.notifier3.notify.assert_not_called()
def test_disabled_notify_download(self):
p1 = PropertyMock(return_value=NotifierType.short_text)
type(self.notifier1).get_type = p1
p2 = PropertyMock(return_value=NotifierType.full_text)
type(self.notifier2).get_type = p2
message1 = "Test message 1"
message2 = "Test message 2"
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify_download(message1)
notifier_execute.notify_download(message2)
self.notifier1.notify.assert_has_calls([
call("Monitorrent Update", message1),
call("Monitorrent Update", message2)
])
self.notifier2.notify.assert_not_called()
self.notifier3.notify.assert_called_once_with(
"Monitorrent Update",
"Monitorrent execute result\n" + message1 + "\n" + message2)
levels = ['ERROR', 'STATUS_CHANGED']
self.settings_manager.get_external_notifications_levels = Mock(
return_value=levels)
self.notifier1.notify.reset_mock()
self.notifier2.notify.reset_mock()
self.notifier3.notify.reset_mock()
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify_download(message1)
notifier_execute.notify_download(message2)
self.notifier1.notify.assert_not_called()
self.notifier2.notify.assert_not_called()
self.notifier3.notify.assert_not_called()
def test_disabled_notify_status_changed(self):
p1 = PropertyMock(return_value=NotifierType.short_text)
type(self.notifier1).get_type = p1
p2 = PropertyMock(return_value=NotifierType.full_text)
type(self.notifier2).get_type = p2
message1 = "Test message 1"
message2 = "Test message 2"
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify_status_changed(message1)
notifier_execute.notify_status_changed(message2)
self.notifier1.notify.assert_has_calls([
call("Monitorrent Update", message1),
call("Monitorrent Update", message2)
])
self.notifier2.notify.assert_not_called()
self.notifier3.notify.assert_called_once_with(
"Monitorrent Update",
"Monitorrent execute result\n" + message1 + "\n" + message2)
levels = ['DOWNLOAD', 'ERROR']
self.settings_manager.get_external_notifications_levels = Mock(
return_value=levels)
self.notifier1.notify.reset_mock()
self.notifier2.notify.reset_mock()
self.notifier3.notify.reset_mock()
with self.notifier_manager.execute() as notifier_execute:
notifier_execute.notify_status_changed(message1)
notifier_execute.notify_status_changed(message2)
self.notifier1.notify.assert_not_called()
self.notifier2.notify.assert_not_called()
self.notifier3.notify.assert_not_called()
def test_init(self):
# noinspection PyTypeChecker
notifier_manager = NotifierManager(self.settings_manager)
self.assertIsNotNone(notifier_manager.notifiers)
