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