class TestAsServer(AbstractServer):
"""
Parent class for testing the server-side of Tribler
"""
def setUp(self):
super(TestAsServer, self).setUp(annotate=False)
self.setUpPreSession()
self.quitting = False
self.session = Session(self.config)
upgrader = self.session.prestart()
while not upgrader.is_done:
time.sleep(0.1)
assert not upgrader.failed, upgrader.current_status
self.session.start()
self.hisport = self.session.get_listen_port()
while not self.session.lm.initComplete:
time.sleep(1)
self.annotate(self._testMethodName, start=True)
def setUpPreSession(self):
""" Should set self.config_path and self.config """
self.config = SessionStartupConfig()
self.config.set_state_dir(self.getStateDir())
self.config.set_torrent_checking(False)
self.config.set_multicast_local_peer_discovery(False)
self.config.set_megacache(False)
self.config.set_dispersy(False)
self.config.set_mainline_dht(False)
self.config.set_torrent_store(False)
self.config.set_enable_torrent_search(False)
self.config.set_enable_channel_search(False)
self.config.set_torrent_collecting(False)
self.config.set_libtorrent(False)
self.config.set_dht_torrent_collecting(False)
self.config.set_videoplayer(False)
self.config.set_enable_metadata(False)
self.config.set_upgrader_enabled(False)
def tearDown(self):
self.annotate(self._testMethodName, start=False)
""" unittest test tear down code """
if self.session is not None:
self._shutdown_session(self.session)
Session.del_instance()
time.sleep(10)
gc.collect()
ts = enumerate_threads()
self._logger.debug("test_as_server: Number of threads still running %d", len(ts))
for t in ts:
self._logger.debug("Thread still running %s, daemon: %s, instance: %s", t.getName(), t.isDaemon(), t)
super(TestAsServer, self).tearDown(annotate=False)
def _shutdown_session(self, session):
session_shutdown_start = time.time()
waittime = 60
session.shutdown()
while not session.has_shutdown():
diff = time.time() - session_shutdown_start
assert diff < waittime, "test_as_server: took too long for Session to shutdown"
self._logger.debug(
"Waiting for Session to shutdown, will wait for an additional %d seconds", (waittime - diff))
wx.SafeYield()
time.sleep(1)
self._logger.debug("Session has shut down")
def assert_(self, boolean, reason=None, do_assert=True, tribler_session=None, dump_statistics=False):
if not boolean:
# print statistics if needed
if tribler_session and dump_statistics:
self._print_statistics(tribler_session.get_statistics())
self.quit()
assert boolean, reason
@blocking_call_on_reactor_thread
def _print_statistics(self, statistics_dict):
def _print_data_dict(data_dict, level):
for k, v in data_dict.iteritems():
indents = u'-' + u'-' * 2 * level
if isinstance(v, basestring):
self._logger.debug(u"%s %s: %s", indents, k, v)
elif isinstance(v, dict):
self._logger.debug(u"%s %s:", indents, k)
_print_data_dict(v, level + 1)
else:
# ignore other types for the moment
continue
self._logger.debug(u"========== Tribler Statistics BEGIN ==========")
_print_data_dict(statistics_dict, 0)
self._logger.debug(u"========== Tribler Statistics END ==========")
def startTest(self, callback):
self.quitting = False
callback()
def callLater(self, seconds, callback):
if not self.quitting:
if seconds:
time.sleep(seconds)
callback()
def CallConditional(self, timeout, condition, callback, assert_message=None, assert_callback=None,
tribler_session=None, dump_statistics=False):
t = time.time()
def DoCheck():
if not self.quitting:
# only use the last two parts as the ID because the full name is too long
test_id = self.id()
test_id = '.'.join(test_id.split('.')[-2:])
if time.time() - t < timeout:
try:
if condition():
self._logger.debug("%s - condition satisfied after %d seconds, calling callback '%s'",
test_id, time.time() - t, callback.__name__)
callback()
else:
self.callLater(0.5, DoCheck)
except:
print_exc()
self.assert_(False, '%s - Condition or callback raised an exception, quitting (%s)' %
(test_id, assert_message or "no-assert-msg"), do_assert=False)
else:
self._logger.debug("%s - %s, condition was not satisfied in %d seconds (%s)",
test_id,
('calling callback' if assert_callback else 'quitting'),
timeout,
assert_message or "no-assert-msg")
assertcall = assert_callback if assert_callback else self.assert_
kwargs = {}
if assertcall == self.assert_:
kwargs = {'tribler_session': tribler_session, 'dump_statistics': dump_statistics}
assertcall(False, "%s - %s - Condition was not satisfied in %d seconds" %
(test_id, assert_message, timeout), do_assert=False, **kwargs)
self.callLater(0, DoCheck)
def quit(self):
self.quitting = True
class TestAsServer(AbstractServer):
"""
Parent class for testing the server-side of Tribler
"""
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestAsServer, self).setUp(annotate=False)
self.setUpPreSession()
self.quitting = False
self.seeding_deferred = Deferred()
self.seeder_session = None
self.session = Session(self.config)
self.tribler_started_deferred = self.session.start()
yield self.tribler_started_deferred
self.assertTrue(self.session.lm.initComplete)
self.hisport = self.session.get_listen_port()
self.annotate(self._testMethodName, start=True)
def setUpPreSession(self):
""" Should set self.config_path and self.config """
self.config = SessionStartupConfig()
self.config.set_state_dir(self.getStateDir())
self.config.set_torrent_checking(False)
self.config.set_multicast_local_peer_discovery(False)
self.config.set_megacache(False)
self.config.set_dispersy(False)
self.config.set_mainline_dht(False)
self.config.set_torrent_store(False)
self.config.set_enable_torrent_search(False)
self.config.set_enable_channel_search(False)
self.config.set_torrent_collecting(False)
self.config.set_libtorrent(False)
self.config.set_dht_torrent_collecting(False)
self.config.set_videoserver_enabled(False)
self.config.set_enable_metadata(False)
self.config.set_upgrader_enabled(False)
self.config.set_http_api_enabled(False)
self.config.set_tunnel_community_enabled(False)
self.config.set_creditmining_enable(False)
self.config.set_enable_multichain(False)
@blocking_call_on_reactor_thread
@inlineCallbacks
def tearDown(self, annotate=True):
self.annotate(self._testMethodName, start=False)
""" unittest test tear down code """
if self.session is not None:
assert self.session is Session.get_instance()
yield self.session.shutdown()
assert self.session.has_shutdown()
Session.del_instance()
yield self.stop_seeder()
ts = enumerate_threads()
self._logger.debug(
"test_as_server: Number of threads still running %d", len(ts))
for t in ts:
self._logger.debug(
"Thread still running %s, daemon: %s, instance: %s",
t.getName(), t.isDaemon(), t)
yield super(TestAsServer, self).tearDown(annotate=False)
def create_local_torrent(self, source_file):
'''
This method creates a torrent from a local file and saves the torrent in the session state dir.
Note that the source file needs to exist.
'''
self.assertTrue(os.path.exists(source_file))
tdef = TorrentDef()
tdef.add_content(source_file)
tdef.set_tracker("http://localhost/announce")
tdef.finalize()
torrent_path = os.path.join(self.session.get_state_dir(),
"seed.torrent")
tdef.save(torrent_path)
return tdef, torrent_path
def setup_seeder(self, tdef, seed_dir):
self.seed_config = SessionStartupConfig()
self.seed_config.set_torrent_checking(False)
self.seed_config.set_multicast_local_peer_discovery(False)
self.seed_config.set_megacache(False)
self.seed_config.set_dispersy(False)
self.seed_config.set_mainline_dht(False)
self.seed_config.set_torrent_store(False)
self.seed_config.set_enable_torrent_search(False)
self.seed_config.set_enable_channel_search(False)
self.seed_config.set_torrent_collecting(False)
self.seed_config.set_libtorrent(True)
self.seed_config.set_dht_torrent_collecting(False)
self.seed_config.set_videoserver_enabled(False)
self.seed_config.set_enable_metadata(False)
self.seed_config.set_upgrader_enabled(False)
self.seed_config.set_tunnel_community_enabled(False)
self.seed_config.set_state_dir(self.getStateDir(2))
def start_seed_download(_):
self.dscfg_seed = DownloadStartupConfig()
self.dscfg_seed.set_dest_dir(seed_dir)
d = self.seeder_session.start_download_from_tdef(
tdef, self.dscfg_seed)
d.set_state_callback(self.seeder_state_callback)
self._logger.debug(
"starting to wait for download to reach seeding state")
self.seeder_session = Session(self.seed_config, ignore_singleton=True)
self.seeder_session.start().addCallback(start_seed_download)
return self.seeding_deferred
def stop_seeder(self):
if self.seeder_session is not None:
return self.seeder_session.shutdown()
return succeed(None)
def seeder_state_callback(self, ds):
d = ds.get_download()
self._logger.debug("seeder status: %s %s %s",
repr(d.get_def().get_name()),
dlstatus_strings[ds.get_status()],
ds.get_progress())
if ds.get_status() == DLSTATUS_SEEDING:
self.seeding_deferred.callback(None)
return 0.0, False
return 1.0, False
