def test_get_plugins(self):
clients = self.clients_manager.clients
get_plugins_mock = Mock(return_value=clients)
with patch('monitorrent.plugin_managers.get_plugins',
get_plugins_mock):
self.clients_manager = ClientsManager()
self.assertEqual(clients, self.clients_manager.clients)
def test_successful_update_settings(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.set_settings = MagicMock(return_value=True)
client = Client(clients_manager)
self.api.add_route('/api/clients/{client}', client)
self.simulate_request('/api/clients/{0}'.format(1), method="PUT",
body=json.dumps({'login': '******', 'password': '******'}))
self.assertEqual(self.srmock.status, falcon.HTTP_NO_CONTENT)
def test_check_client_not_found(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.check_connection = MagicMock(side_effect=KeyError)
client = ClientCheck(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/clients/{client}/check', client)
self.simulate_request('/api/clients/{0}/check'.format('tracker.org'))
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
def test_check_client_error(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.check_connection = MagicMock(side_effect=Exception)
client = ClientCheck(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/clients/{client}/check', client)
self.simulate_request('/api/clients/{0}/check'.format('tracker.org'))
self.assertEqual(self.srmock.status, falcon.HTTP_INTERNAL_SERVER_ERROR)
def test_get_default_not_found(self):
clients_manager = ClientsManager({'tracker.org': ClientCollectionTest.TestClient()})
clients_manager.default_client = None
client = DefaultClient(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/default_client', client)
body = self.simulate_request('/api/default_client', decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
def test_get_default_not_found(self):
clients_manager = ClientsManager({'tracker.org': ClientCollectionTest.TestClient()})
clients_manager.default_client = None
client = DefaultClient(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/default_client', client)
body = self.simulate_request('/api/default_client', decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
def test_eroor_update_settings(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.set_settings = MagicMock(side_effect=Exception)
client = Client(clients_manager)
self.api.add_route('/api/clients/{client}', client)
self.simulate_request('/api/clients/{0}'.format(1), method="PUT",
body=json.dumps({'login': '******', 'password': '******'}))
self.assertEqual(self.srmock.status, falcon.HTTP_INTERNAL_SERVER_ERROR)
def test_not_found_update_settings(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.set_settings = MagicMock(side_effect=KeyError)
client = Client(clients_manager)
self.api.add_route('/api/clients/{client}', client)
self.simulate_request('/api/clients/{0}'.format(1), method="PUT",
body=json.dumps({'login': '******', 'password': '******'}))
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
def setUp(self):
super(ClientsManagerTest, self).setUp()
self.client1 = Mock()
self.client2 = Mock()
self.clients_manager = ClientsManager(
{
self.CLIENT1_NAME: self.client1,
self.CLIENT2_NAME: self.client2
}, self.CLIENT1_NAME)
def test_not_found_settings(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.get_settings = MagicMock(side_effect=KeyError)
client = Client(clients_manager)
self.api.add_route('/api/clients/{client}', client)
self.simulate_request('/api/clients/{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_get_settings_error(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.get_settings = MagicMock(side_effect=Exception)
client = Client(clients_manager)
self.api.add_route('/api/clients/{client}', client)
self.simulate_request('/api/clients/{0}'.format(1))
self.assertEqual(self.srmock.status, falcon.HTTP_INTERNAL_SERVER_ERROR)
self.assertTrue('application/json' in self.srmock.headers_dict['Content-Type'])
def test_get_last_execute(self):
execute_mock = Mock()
self.trackers_manager.execute = execute_mock
clients_manager = ClientsManager({})
self.TestDatetime.mock_now = datetime.now(pytz.utc)
with patch('monitorrent.engine.datetime',
self.TestDatetime(2015, 8, 28)):
engine_runner = DBEngineRunner(Logger(), self.trackers_manager,
clients_manager)
self.assertIsNone(engine_runner.last_execute)
engine_runner.execute(None)
sleep(0.1)
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
engine_runner = DBEngineRunner(Logger(), self.trackers_manager,
clients_manager)
self.assertEqual(self.TestDatetime.mock_now,
engine_runner.last_execute)
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
def test_manual_execute_with_ids_ignored_while_in_execute(self):
waiter = Event()
long_execute_waiter = Event()
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
waiter.set()
long_execute_waiter.wait(1)
self.assertTrue(long_execute_waiter.is_set)
execute_mock = Mock(side_effect=execute)
self.trackers_manager.execute = execute_mock
clients_manager = ClientsManager({})
engine_runner = EngineRunner(Logger(),
self.trackers_manager,
clients_manager,
interval=1)
engine_runner.execute(None)
waiter.wait(0.3)
waiter.clear()
ids = [1, 2, 3]
engine_runner.execute(ids)
long_execute_waiter.set()
waiter.wait(0.3)
self.assertTrue(waiter.is_set)
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
execute_mock.assert_called_once_with(ANY, None)
def test_exeption_in_finally_execute(self):
waiter = Event()
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
waiter.set()
execute_mock = Mock(side_effect=execute)
self.trackers_manager.execute = execute_mock
clients_manager = ClientsManager({})
logger = Logger()
logger.finished = Mock(side_effect=Exception("Failed to save"))
engine_runner = EngineRunner(logger,
self.trackers_manager,
clients_manager,
interval=0.1)
waiter.wait(1)
self.assertTrue(waiter.is_set)
self.assertTrue(engine_runner.is_alive())
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
self.assertEqual(1, execute_mock.call_count)
def test_update_interval_during_execute(self, test_interval):
waiter = Event()
scope = self.Bunch()
scope.first_execute = True
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
engine_runner.interval = test_interval
if scope.first_execute:
scope.start = time()
scope.first_execute = False
else:
scope.end = time()
waiter.set()
execute_mock = Mock(side_effect=execute)
self.trackers_manager.execute = execute_mock
clients_manager = ClientsManager({})
engine_runner = EngineRunner(Logger(),
self.trackers_manager,
clients_manager,
interval=0.1)
waiter.wait(2)
self.assertTrue(waiter.is_set)
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
self.assertEqual(2, execute_mock.call_count)
# noinspection PyUnresolvedReferences
delta = scope.end - scope.start
self.assertLessEqual(abs(delta - test_interval), 0.02)
def test_stop_after_multiple_execute(self, value):
waiter = Event()
scope = self.Bunch()
scope.execute_count = 0
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
scope.execute_count += 1
if scope.execute_count < value:
return
waiter.set()
execute_mock = Mock(side_effect=execute)
self.trackers_manager.execute = execute_mock
clients_manager = ClientsManager({})
engine_runner = EngineRunner(Logger(),
self.trackers_manager,
clients_manager,
interval=0.1)
waiter.wait(2)
self.assertTrue(waiter.is_set)
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
self.assertEqual(value, execute_mock.call_count)
def test_get_plugins(self):
clients = self.clients_manager.clients
get_plugins_mock = Mock(return_value=clients)
with patch('monitorrent.plugin_managers.get_plugins', get_plugins_mock):
self.clients_manager = ClientsManager()
self.assertEqual(clients, self.clients_manager.clients)
def test_empty_get_settings(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.get_settings = MagicMock(return_value=None)
client = Client(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/clients/{client}', client)
body = self.simulate_request('/api/clients/{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(ClientsManagerTest, self).setUp()
self.client1 = Mock()
self.client2 = Mock()
self.clients_manager = ClientsManager({self.CLIENT1_NAME: self.client1, self.CLIENT2_NAME: self.client2}, self.CLIENT1_NAME)
def test_check_client(self, value):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
clients_manager.check_connection = MagicMock(return_value=value)
client = ClientCheck(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/clients/{client}/check', client)
body = self.simulate_request('/api/clients/{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 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_set_default_not_found(self):
clients_manager = ClientsManager({'tracker.org': ClientCollectionTest.TestClient()})
client = ClientDefault(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/clients/{client}/default', client)
self.simulate_request('/api/clients/{0}/default'.format('random.org'), method='PUT')
self.assertEqual(self.srmock.status, falcon.HTTP_NOT_FOUND)
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 test_get_default(self):
clients_manager = ClientsManager({'tracker.org': ClientCollectionTest.TestClient()})
client = DefaultClient(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/default_client', client)
body = self.simulate_request('/api/default_client', decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
result = json.loads(body)
assert result == {'name': 'test_client', 'settings': {}, 'fields': {}}
def test_stop_bofore_execute(self):
execute_mock = MagicMock()
self.trackers_manager.execute = execute_mock
clients_manager = ClientsManager({})
engine_runner = EngineRunner(Logger(),
self.trackers_manager,
clients_manager,
interval=0.1)
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
execute_mock.assert_not_called()
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.engine = Engine(self.log_mock, self.clients_manager)
def test_get_all(self):
clients_manager = ClientsManager({'test': ClientCollectionTest.TestClient()})
client_collection = ClientCollection(clients_manager)
self.api.add_route('/api/clients', client_collection)
body = self.simulate_request('/api/clients', 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': ClientCollectionTest.TestClient.form, 'is_default': True})
def test_get_default_with_fields(self):
clients_manager = ClientsManager({'tracker.org': self.TestClientWithFields()})
client = DefaultClient(clients_manager)
client.__no_auth__ = True
self.api.add_route('/api/default_client', client)
body = self.simulate_request('/api/default_client', decode="utf-8")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
result = json.loads(body)
expected_fields = {
'download_dir': u'/mnt/media/download',
'other': None
}
assert result == {'name': 'test_client_with_fields', 'settings': {}, 'fields': expected_fields}
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 test_stop_after_execute(self):
waiter = Event()
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
waiter.set()
execute_mock = Mock(side_effect=execute)
self.trackers_manager.execute = execute_mock
clients_manager = ClientsManager({})
engine_runner = EngineRunner(Logger(),
self.trackers_manager,
clients_manager,
interval=0.1)
waiter.wait(1)
self.assertTrue(waiter.is_set)
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
self.assertEqual(1, execute_mock.call_count)
def test_set_interval(self, value):
execute_mock = Mock()
self.trackers_manager.execute = execute_mock
clients_manager = ClientsManager({})
engine_runner = DBEngineRunner(Logger(), self.trackers_manager,
clients_manager)
self.assertEqual(7200, engine_runner.interval)
engine_runner.interval = value
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
engine_runner = DBEngineRunner(Logger(), self.trackers_manager,
clients_manager)
self.assertEqual(value, engine_runner.interval)
engine_runner.stop()
engine_runner.join(1)
self.assertFalse(engine_runner.is_alive())
def test_empty_clients(self):
clients_amanger = ClientsManager({})
self.assertFalse(clients_amanger.add_torrent('!torrent'))
self.assertFalse(clients_amanger.find_torrent('hash'))
self.assertFalse(clients_amanger.remove_torrent('hash'))
class ClientsManagerTest(TestCase):
CLIENT1_NAME = 'client1'
CLIENT2_NAME = 'client2'
def setUp(self):
super(ClientsManagerTest, self).setUp()
self.client1 = Mock()
self.client2 = Mock()
self.clients_manager = ClientsManager({self.CLIENT1_NAME: self.client1, self.CLIENT2_NAME: self.client2}, self.CLIENT1_NAME)
def test_get_settings(self):
settings1 = {'login': '******', 'password': '******'}
settings2 = {'login': '******', 'password': '******'}
get_settings1_mock = MagicMock(return_value=settings1)
get_settings2_mock = MagicMock(return_value=settings2)
self.client1.get_settings = get_settings1_mock
self.client2.get_settings = get_settings2_mock
settings = self.clients_manager.get_settings(self.CLIENT1_NAME)
self.assertEqual(settings1, settings)
get_settings1_mock.assert_called_with()
get_settings2_mock.assert_not_called()
def test_set_settings(self):
settings = {'login': '******', 'password': '******'}
set_settings1_mock = MagicMock(return_value=True)
set_settings2_mock = MagicMock(return_value=True)
self.client1.set_settings = set_settings1_mock
self.client2.set_settings = set_settings2_mock
self.assertTrue(self.clients_manager.set_settings(self.CLIENT1_NAME, settings))
set_settings1_mock.assert_called_with(settings)
set_settings2_mock.assert_not_called()
@data(True, False)
def test_check_connection(self, value):
check_connection_mock1 = MagicMock(return_value=value)
check_connection_mock2 = MagicMock(return_value=value)
self.client1.check_connection = check_connection_mock1
self.client2.check_connection = check_connection_mock2
self.assertEqual(value, self.clients_manager.check_connection(self.CLIENT1_NAME))
self.assertEqual(value, self.clients_manager.check_connection(self.CLIENT2_NAME))
check_connection_mock1.assert_called_once_with()
check_connection_mock2.assert_called_once_with()
def test_find_torrent_true(self):
result = {'name': 'movie.torrent'}
find_torrent_mock1 = MagicMock(return_value=result)
find_torrent_mock2 = MagicMock(return_value=None)
self.client1.find_torrent = find_torrent_mock1
self.client2.find_torrent = find_torrent_mock2
torrent_hash = 'hash'
self.assertEqual(result, self.clients_manager.find_torrent(torrent_hash))
find_torrent_mock1.assert_called_once_with(torrent_hash)
find_torrent_mock2.assert_not_called()
def test_find_torrent_true_default_client2(self):
result = {'name': 'movie.torrent'}
find_torrent_mock1 = MagicMock(return_value=None)
find_torrent_mock2 = MagicMock(return_value=result)
self.client1.find_torrent = find_torrent_mock1
self.client2.find_torrent = find_torrent_mock2
torrent_hash = 'hash'
self.clients_manager.set_default(self.CLIENT2_NAME)
self.assertEqual(result, self.clients_manager.find_torrent(torrent_hash))
find_torrent_mock1.assert_not_called()
find_torrent_mock2.assert_called_once_with(torrent_hash)
def test_find_torrent_false(self):
find_torrent_mock1 = MagicMock(return_value=None)
find_torrent_mock2 = MagicMock(return_value=None)
self.client1.find_torrent = find_torrent_mock1
self.client2.find_torrent = find_torrent_mock2
torrent_hash = 'hash'
self.assertFalse(self.clients_manager.find_torrent(torrent_hash))
find_torrent_mock1.assert_called_once_with(torrent_hash)
find_torrent_mock2.assert_not_called()
def test_add_torrent_true(self):
add_torrent_mock1 = MagicMock(return_value=True)
add_torrent_mock2 = MagicMock(return_value=False)
self.client1.add_torrent = add_torrent_mock1
self.client2.add_torrent = add_torrent_mock2
torrent = b'!torrent_file'
self.assertTrue(self.clients_manager.add_torrent(torrent))
add_torrent_mock1.assert_called_once_with(torrent)
add_torrent_mock2.assert_not_called()
def test_add_torrent_true_default_client2(self):
add_torrent_mock1 = MagicMock(return_value=False)
add_torrent_mock2 = MagicMock(return_value=True)
self.client1.add_torrent = add_torrent_mock1
self.client2.add_torrent = add_torrent_mock2
torrent = '!torrent_file'
self.clients_manager.set_default(self.CLIENT2_NAME)
self.assertTrue(self.clients_manager.add_torrent(torrent))
add_torrent_mock1.assert_not_called()
add_torrent_mock2.assert_called_once_with(torrent)
def test_add_torrent_false(self):
add_torrent_mock1 = MagicMock(return_value=False)
add_torrent_mock2 = MagicMock(return_value=False)
self.client1.add_torrent = add_torrent_mock1
self.client2.add_torrent = add_torrent_mock2
torrent = b'!torrent_file'
self.assertFalse(self.clients_manager.add_torrent(torrent))
add_torrent_mock1.assert_called_once_with(torrent)
add_torrent_mock2.assert_not_called()
def test_remove_torrent_true(self):
remove_torrent_mock1 = MagicMock(return_value=False)
remove_torrent_mock2 = MagicMock(return_value=True)
self.client1.remove_torrent = remove_torrent_mock1
self.client2.remove_torrent = remove_torrent_mock2
torrent_hash = 'hash'
self.assertFalse(self.clients_manager.remove_torrent(torrent_hash))
remove_torrent_mock1.assert_called_once_with(torrent_hash)
remove_torrent_mock2.assert_not_called()
def test_remove_torrent_true_default_client2(self):
remove_torrent_mock1 = MagicMock(return_value=False)
remove_torrent_mock2 = MagicMock(return_value=True)
self.client1.remove_torrent = remove_torrent_mock1
self.client2.remove_torrent = remove_torrent_mock2
torrent_hash = 'hash'
self.clients_manager.set_default(self.CLIENT2_NAME)
self.assertTrue(self.clients_manager.remove_torrent(torrent_hash))
remove_torrent_mock1.assert_not_called()
remove_torrent_mock2.assert_called_once_with(torrent_hash)
def test_remove_torrent_false(self):
remove_torrent_mock1 = MagicMock(return_value=False)
remove_torrent_mock2 = MagicMock(return_value=False)
self.client1.remove_torrent = remove_torrent_mock1
self.client2.remove_torrent = remove_torrent_mock2
torrent_hash = 'hash'
self.assertFalse(self.clients_manager.remove_torrent(torrent_hash))
remove_torrent_mock1.assert_called_once_with(torrent_hash)
remove_torrent_mock2.assert_not_called()
def test_get_plugins(self):
clients = self.clients_manager.clients
get_plugins_mock = Mock(return_value=clients)
with patch('monitorrent.plugin_managers.get_plugins', get_plugins_mock):
self.clients_manager = ClientsManager()
self.assertEqual(clients, self.clients_manager.clients)
def test_get_default(self):
self.assertEqual(self.client1, self.clients_manager.get_default())
self.clients_manager.set_default(self.CLIENT2_NAME)
self.assertEqual(self.client2, self.clients_manager.get_default())
self.clients_manager.set_default(self.CLIENT1_NAME)
self.assertEqual(self.client1, self.clients_manager.get_default())
def test_empty_clients(self):
clients_amanger = ClientsManager({})
self.assertFalse(clients_amanger.add_torrent('!torrent'))
self.assertFalse(clients_amanger.find_torrent('hash'))
self.assertFalse(clients_amanger.remove_torrent('hash'))
def test_unknow_client(self):
with self.assertRaises(KeyError):
self.clients_manager.set_default('random_name')
def test_empty_clients(self):
clients_amanger = ClientsManager({})
self.assertFalse(clients_amanger.add_torrent('!torrent', None))
self.assertFalse(clients_amanger.find_torrent('hash'))
self.assertFalse(clients_amanger.remove_torrent('hash'))
class ClientsManagerTest(TestCase):
CLIENT1_NAME = 'client1'
CLIENT2_NAME = 'client2'
def setUp(self):
super(ClientsManagerTest, self).setUp()
self.client1 = Mock()
self.client2 = Mock()
self.clients_manager = ClientsManager(
{
self.CLIENT1_NAME: self.client1,
self.CLIENT2_NAME: self.client2
}, self.CLIENT1_NAME)
def test_get_settings(self):
settings1 = {'login': '******', 'password': '******'}
settings2 = {'login': '******', 'password': '******'}
get_settings1_mock = MagicMock(return_value=settings1)
get_settings2_mock = MagicMock(return_value=settings2)
self.client1.get_settings = get_settings1_mock
self.client2.get_settings = get_settings2_mock
settings = self.clients_manager.get_settings(self.CLIENT1_NAME)
self.assertEqual(settings1, settings)
get_settings1_mock.assert_called_with()
get_settings2_mock.assert_not_called()
def test_set_settings(self):
settings = {'login': '******', 'password': '******'}
set_settings1_mock = MagicMock(return_value=True)
set_settings2_mock = MagicMock(return_value=True)
self.client1.set_settings = set_settings1_mock
self.client2.set_settings = set_settings2_mock
self.clients_manager.set_settings(self.CLIENT1_NAME, settings)
set_settings1_mock.assert_called_with(settings)
set_settings2_mock.assert_not_called()
@data(True, False)
def test_check_connection(self, value):
check_connection_mock1 = MagicMock(return_value=value)
check_connection_mock2 = MagicMock(return_value=value)
self.client1.check_connection = check_connection_mock1
self.client2.check_connection = check_connection_mock2
self.assertEqual(
value, self.clients_manager.check_connection(self.CLIENT1_NAME))
self.assertEqual(
value, self.clients_manager.check_connection(self.CLIENT2_NAME))
check_connection_mock1.assert_called_once_with()
check_connection_mock2.assert_called_once_with()
def test_find_torrent_true(self):
result = {'name': 'movie.torrent'}
find_torrent_mock1 = MagicMock(return_value=result)
find_torrent_mock2 = MagicMock(return_value=None)
self.client1.find_torrent = find_torrent_mock1
self.client2.find_torrent = find_torrent_mock2
torrent_hash = 'hash'
self.assertEqual(result,
self.clients_manager.find_torrent(torrent_hash))
find_torrent_mock1.assert_called_once_with(torrent_hash)
find_torrent_mock2.assert_not_called()
def test_find_torrent_true_default_client2(self):
result = {'name': 'movie.torrent'}
find_torrent_mock1 = MagicMock(return_value=None)
find_torrent_mock2 = MagicMock(return_value=result)
self.client1.find_torrent = find_torrent_mock1
self.client2.find_torrent = find_torrent_mock2
torrent_hash = 'hash'
self.clients_manager.set_default(self.CLIENT2_NAME)
self.assertEqual(result,
self.clients_manager.find_torrent(torrent_hash))
find_torrent_mock1.assert_not_called()
find_torrent_mock2.assert_called_once_with(torrent_hash)
def test_find_torrent_false(self):
find_torrent_mock1 = MagicMock(return_value=None)
find_torrent_mock2 = MagicMock(return_value=None)
self.client1.find_torrent = find_torrent_mock1
self.client2.find_torrent = find_torrent_mock2
torrent_hash = 'hash'
self.assertFalse(self.clients_manager.find_torrent(torrent_hash))
find_torrent_mock1.assert_called_once_with(torrent_hash)
find_torrent_mock2.assert_not_called()
def test_add_torrent_true(self):
add_torrent_mock1 = MagicMock(return_value=True)
add_torrent_mock2 = MagicMock(return_value=False)
self.client1.add_torrent = add_torrent_mock1
self.client2.add_torrent = add_torrent_mock2
torrent = b'!torrent_file'
self.assertTrue(self.clients_manager.add_torrent(torrent, None))
add_torrent_mock1.assert_called_once_with(torrent, None)
add_torrent_mock2.assert_not_called()
def test_add_torrent_true_default_client2(self):
add_torrent_mock1 = MagicMock(return_value=False)
add_torrent_mock2 = MagicMock(return_value=True)
self.client1.add_torrent = add_torrent_mock1
self.client2.add_torrent = add_torrent_mock2
torrent = '!torrent_file'
self.clients_manager.set_default(self.CLIENT2_NAME)
self.assertTrue(self.clients_manager.add_torrent(torrent, None))
add_torrent_mock1.assert_not_called()
add_torrent_mock2.assert_called_once_with(torrent, None)
def test_add_torrent_false(self):
add_torrent_mock1 = MagicMock(return_value=False)
add_torrent_mock2 = MagicMock(return_value=False)
self.client1.add_torrent = add_torrent_mock1
self.client2.add_torrent = add_torrent_mock2
torrent = b'!torrent_file'
self.assertFalse(self.clients_manager.add_torrent(torrent, None))
add_torrent_mock1.assert_called_once_with(torrent, None)
add_torrent_mock2.assert_not_called()
def test_remove_torrent_true(self):
remove_torrent_mock1 = MagicMock(return_value=False)
remove_torrent_mock2 = MagicMock(return_value=True)
self.client1.remove_torrent = remove_torrent_mock1
self.client2.remove_torrent = remove_torrent_mock2
torrent_hash = 'hash'
self.assertFalse(self.clients_manager.remove_torrent(torrent_hash))
remove_torrent_mock1.assert_called_once_with(torrent_hash)
remove_torrent_mock2.assert_not_called()
def test_remove_torrent_true_default_client2(self):
remove_torrent_mock1 = MagicMock(return_value=False)
remove_torrent_mock2 = MagicMock(return_value=True)
self.client1.remove_torrent = remove_torrent_mock1
self.client2.remove_torrent = remove_torrent_mock2
torrent_hash = 'hash'
self.clients_manager.set_default(self.CLIENT2_NAME)
self.assertTrue(self.clients_manager.remove_torrent(torrent_hash))
remove_torrent_mock1.assert_not_called()
remove_torrent_mock2.assert_called_once_with(torrent_hash)
def test_remove_torrent_false(self):
remove_torrent_mock1 = MagicMock(return_value=False)
remove_torrent_mock2 = MagicMock(return_value=False)
self.client1.remove_torrent = remove_torrent_mock1
self.client2.remove_torrent = remove_torrent_mock2
torrent_hash = 'hash'
self.assertFalse(self.clients_manager.remove_torrent(torrent_hash))
remove_torrent_mock1.assert_called_once_with(torrent_hash)
remove_torrent_mock2.assert_not_called()
def test_get_plugins(self):
clients = self.clients_manager.clients
get_plugins_mock = Mock(return_value=clients)
with patch('monitorrent.plugin_managers.get_plugins',
get_plugins_mock):
self.clients_manager = ClientsManager()
self.assertEqual(clients, self.clients_manager.clients)
def test_get_default(self):
self.assertEqual(self.client1, self.clients_manager.get_default())
self.clients_manager.set_default(self.CLIENT2_NAME)
self.assertEqual(self.client2, self.clients_manager.get_default())
self.clients_manager.set_default(self.CLIENT1_NAME)
self.assertEqual(self.client1, self.clients_manager.get_default())
def test_empty_clients(self):
clients_amanger = ClientsManager({})
self.assertFalse(clients_amanger.add_torrent('!torrent', None))
self.assertFalse(clients_amanger.find_torrent('hash'))
self.assertFalse(clients_amanger.remove_torrent('hash'))
def test_unknow_client(self):
with self.assertRaises(KeyError):
self.clients_manager.set_default('random_name')
