def subtest_download(self): """ Now download the file via another Session """ self.config2 = self.config.copy() # not really necess self.config2.set_state_dir(self.getStateDir(2)) self.config2.set_listen_port(self.mylistenport) self.session2 = Session(self.config2, ignore_singleton=True) # Allow session2 to start print >> sys.stderr, "test: downloader: Sleeping 3 secs to let Session2 start" time.sleep(3) tdef2 = TorrentDef.load(self.torrentfn) dscfg2 = DownloadStartupConfig() dscfg2.set_dest_dir(self.getDestDir(2)) dscfg2.set_video_event_callback(self.downloader_vod_ready_callback) d = self.session2.start_download(tdef2, dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(40) # To test if BITFIELD is indeed wrapping around. self.subtest_connect2downloader() time.sleep(80)
class TestAsServer(unittest.TestCase): """ Parent class for testing the server-side of Tribler """ def setUp(self): """ unittest test setup code """ self.setUpPreSession() self.session = Session(self.config) self.hisport = self.session.get_listen_port() self.setUpPostSession() def setUpPreSession(self): """ Should set self.config_path and self.config """ self.config_path = tempfile.mkdtemp() self.config = SessionStartupConfig() self.config.set_state_dir(self.config_path) self.config.set_listen_port(random.randint(10000, 60000)) self.config.set_buddycast(False) self.config.set_start_recommender(False) self.config.set_torrent_checking(False) self.config.set_superpeer(False) self.config.set_dialback(False) self.config.set_social_networking(False) self.config.set_remote_query(False) self.config.set_internal_tracker(False) self.config.set_bartercast(False) self.config.set_multicast_local_peer_discovery(False) self.config.set_dispersy(False) # Assume all test scripts are run from Tribler/Test self.config.set_install_dir(os.path.abspath(os.path.join('..','..'))) self.my_keypair = EC.gen_params(EC.NID_sect233k1) self.my_keypair.gen_key() def setUpPostSession(self): """ Should set self.his_keypair """ keypair_filename = os.path.join(self.config_path,'ec.pem') self.his_keypair = EC.load_key(keypair_filename) def tearDown(self): """ unittest test tear down code """ if self.session is not None: self.session.shutdown() print >>sys.stderr,"test_as_server: sleeping after session shutdown" time.sleep(2) try: shutil.rmtree(self.config_path) except: # Not fatal if something goes wrong here, and Win32 often gives # spurious Permission Denied errors. print_exc()
class TestAsServer(unittest.TestCase): """ Parent class for testing the server-side of Tribler """ def setUp(self): """ unittest test setup code """ self.setUpPreSession() self.session = Session(self.config) self.hisport = self.session.get_listen_port() self.setUpPostSession() def setUpPreSession(self): """ Should set self.config_path and self.config """ self.config_path = tempfile.mkdtemp() self.config = SessionStartupConfig() self.config.set_state_dir(self.config_path) self.config.set_listen_port(random.randint(10000, 60000)) self.config.set_buddycast(False) self.config.set_start_recommender(False) self.config.set_torrent_checking(False) self.config.set_superpeer(False) self.config.set_dialback(False) self.config.set_social_networking(False) self.config.set_remote_query(False) self.config.set_internal_tracker(False) self.config.set_bartercast(False) self.config.set_multicast_local_peer_discovery(False) self.config.set_dispersy(False) # Assume all test scripts are run from Tribler/Test self.config.set_install_dir(os.path.abspath(os.path.join('..', '..'))) self.my_keypair = EC.gen_params(EC.NID_sect233k1) self.my_keypair.gen_key() def setUpPostSession(self): """ Should set self.his_keypair """ keypair_filename = os.path.join(self.config_path, 'ec.pem') self.his_keypair = EC.load_key(keypair_filename) def tearDown(self): """ unittest test tear down code """ if self.session is not None: self.session.shutdown() print >> sys.stderr, "test_as_server: sleeping after session shutdown" time.sleep(2) try: shutil.rmtree(self.config_path) except: # Not fatal if something goes wrong here, and Win32 often gives # spurious Permission Denied errors. print_exc()
def subtest_download(self): """ Now download the file via another Session """ self.session2 = Session(self.config2, ignore_singleton=True) self.session2.start() time.sleep(5) tdef2 = TorrentDef.load(self.torrentfn) d = self.session2.start_download(tdef2, self.dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(5) d.add_peer(("127.0.0.1", self.hisport)) assert self.downloading_event.wait(60)
def subtest_download(self): """ Now download the file via another Session """ self.config2 = self.config.copy() # not really necess self.config_path2 = tempfile.mkdtemp() self.config2.set_state_dir(self.config_path2) self.config2.set_listen_port(self.mylistenport) self.session2 = Session(self.config2, ignore_singleton=True) # Allow session2 to start print >> sys.stderr, "test: Sleeping 3 secs to let Session2 start" time.sleep(3) tdef2 = TorrentDef.load(self.torrentfn) dscfg2 = DownloadStartupConfig() dscfg2.set_dest_dir(self.config_path2) d = self.session2.start_download(tdef2, dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(20)
def setUp(self): self.setUpCleanup() self.setUpPreSession() self.quitting = False self.session = Session(self.config) 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 subtest_download(self): """ Now download the file via another Session """ self.config2 = self.config.copy() # not really necess self.config_path2 = tempfile.mkdtemp() self.config2.set_state_dir(self.config_path2) self.config2.set_listen_port(self.mylistenport) self.session2 = Session(self.config2,ignore_singleton=True) # Allow session2 to start print >>sys.stderr,"test: Sleeping 3 secs to let Session2 start" time.sleep(3) tdef2 = TorrentDef.load(self.torrentfn) dscfg2 = DownloadStartupConfig() dscfg2.set_dest_dir(self.config_path2) d = self.session2.start_download(tdef2,dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(20)
class TestSeeding(TestAsServer): """ Testing seeding via new tribler API: """ def setUp(self): """ override TestAsServer """ TestAsServer.setUp(self) print >> sys.stderr, "test: Giving Session time to startup" time.sleep(5) print >> sys.stderr, "test: Session should have started up" def setUpPreSession(self): """ override TestAsServer """ TestAsServer.setUpPreSession(self) self.config.set_overlay(False) self.config.set_internal_tracker(True) self.mylistenport = 4810 def setUpPostSession(self): pass @skip("We need to migrate this to swift") def test_live_torrent(self): """ I want to start a Tribler client once and then connect to it many times. So there must be only one test method to prevent setUp() from creating a new client every time. The code is constructed so unittest will show the name of the (sub)test where the error occured in the traceback it prints. """ self.setup_seeder() time.sleep(10) # self.subtest_connect2downloader() self.subtest_download() def setup_seeder(self): self.tdef = TorrentDef() # semi automatic self.bitrate = 6144 piecesize = 32768 self.npieces = 12 playtime = ((self.npieces - 1) * piecesize) / self.bitrate playtimestr = '0:' + str(playtime) # DON'T WORK IF > 60 secs self.tdef.create_live("Test Live", self.bitrate, playtimestr) self.tdef.set_tracker(self.session.get_internal_tracker_url()) self.tdef.set_piece_length(piecesize) self.tdef.finalize() print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo[ 'info']['name'] self.dscfg = DownloadStartupConfig() self.dscfg.set_dest_dir(self.getDestDir()) # File source source = InfiniteSource(piecesize) self.dscfg.set_video_ratelimit(self.bitrate) self.dscfg.set_video_source(source) d = self.session.start_download(self.tdef, self.dscfg) d.set_state_callback(self.seeder_state_callback) def seeder_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: seeder:", dlstatus_strings[ ds.get_status()], ds.get_progress() return (1.0, False) def subtest_download(self): """ Now download the file via another Session """ self.config2 = self.config.copy() # not really necess self.config2.set_state_dir(self.getStateDir(2)) self.config2.set_listen_port(self.mylistenport) self.session2 = Session(self.config2, ignore_singleton=True) # Allow session2 to start print >> sys.stderr, "test: downloader: Sleeping 3 secs to let Session2 start" time.sleep(3) tdef2 = TorrentDef.load(self.torrentfn) dscfg2 = DownloadStartupConfig() dscfg2.set_dest_dir(self.getDestDir(2)) dscfg2.set_video_event_callback(self.downloader_vod_ready_callback) d = self.session2.start_download(tdef2, dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(40) # To test if BITFIELD is indeed wrapping around. self.subtest_connect2downloader() time.sleep(80) def downloader_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: download:", dlstatus_strings[ ds.get_status()], ds.get_progress() return (1.0, False) def downloader_vod_ready_callback(self, d, event, params): """ Called by SessionThread """ if event == VODEVENT_START: stream = params["stream"] while True: # Fake video playback data = stream.read(self.bitrate) if len(data) == 0: break time.sleep(1) def subtest_connect2downloader(self): print >> sys.stderr, "test: verifier: Connecting to seeder to check bitfield" infohash = self.tdef.get_infohash() s = BTConnection('localhost', self.mylistenport, user_infohash=infohash) s.read_handshake_medium_rare() try: s.s.settimeout(10.0) resp = s.recv() self.assert_(len(resp) > 0) print >> sys.stderr, "test: verifier: Got message", getMessageName( resp[0]) self.assert_(resp[0] == EXTEND) resp = s.recv() self.assert_(len(resp) > 0) print >> sys.stderr, "test: verifier: Got 2nd message", getMessageName( resp[0]) self.assert_(resp[0] == BITFIELD) b = Bitfield(self.npieces, resp[1:]) print >> sys.stderr, "test: verifier: Bitfield is", repr( b.toboollist()) b2 = Bitfield(self.npieces) b2[0] = True msg = BITFIELD + b2.tostring() s.send(msg) time.sleep(5) except socket.timeout: print >> sys.stderr, "test: verifier: Timeout, peer didn't reply" self.assert_(False) s.close()
import sys import time from Tribler.Core.Session import * from Tribler.Core.TorrentDef import * def states_callback(dslist): for ds in dslist: d = ds.get_download() print >>sys.stderr,"bctest 1: Stats",`d.get_def().get_name()`,dlstatus_strings[ds.get_status()],ds.get_progress(),"%",ds.get_error(),"up",ds.get_current_speed(UPLOAD),"down",ds.get_current_speed(DOWNLOAD),currentThread().getName() return (10.0,False) if __name__ == "__main__": sscfg = SessionStartupConfig() sscfg.set_state_dir('Session1') sscfg.set_overlay(1) sscfg.set_overlay_log('test.log') sscfg.set_superpeer_file('superpeer1.txt') sscfg.set_listen_port(7011) s = Session(sscfg) s.set_download_states_callback(states_callback,getpeerlist=False) tdef = TorrentDef.load('bla.torrent') d = s.start_download(tdef) time.sleep(3600*24*7)
class TestSeeding(TestAsServer): """ Testing seeding via new tribler API: """ def setUp(self): """ override TestAsServer """ TestAsServer.setUp(self) print >> sys.stderr, "test: Giving Session time to startup" time.sleep(5) print >> sys.stderr, "test: Session should have started up" def setUpPreSession(self): """ override TestAsServer """ TestAsServer.setUpPreSession(self) self.config.set_overlay(False) self.config.set_internal_tracker(True) self.mylistenport = 4810 def setUpPostSession(self): pass @skip("We need to migrate this to swift") def test_live_torrent(self): """ I want to start a Tribler client once and then connect to it many times. So there must be only one test method to prevent setUp() from creating a new client every time. The code is constructed so unittest will show the name of the (sub)test where the error occured in the traceback it prints. """ self.setup_seeder() time.sleep(10) # self.subtest_connect2downloader() self.subtest_download() def setup_seeder(self): self.tdef = TorrentDef() # semi automatic self.bitrate = 6144 piecesize = 32768 self.npieces = 12 playtime = ((self.npieces - 1) * piecesize) / self.bitrate playtimestr = '0:' + str(playtime) # DON'T WORK IF > 60 secs self.tdef.create_live("Test Live", self.bitrate, playtimestr) self.tdef.set_tracker(self.session.get_internal_tracker_url()) self.tdef.set_piece_length(piecesize) self.tdef.finalize() print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo['info']['name'] self.dscfg = DownloadStartupConfig() self.dscfg.set_dest_dir(self.getDestDir()) # File source source = InfiniteSource(piecesize) self.dscfg.set_video_ratelimit(self.bitrate) self.dscfg.set_video_source(source) d = self.session.start_download(self.tdef, self.dscfg) d.set_state_callback(self.seeder_state_callback) def seeder_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: seeder:", dlstatus_strings[ds.get_status()], ds.get_progress() return (1.0, False) def subtest_download(self): """ Now download the file via another Session """ self.config2 = self.config.copy() # not really necess self.config2.set_state_dir(self.getStateDir(2)) self.config2.set_listen_port(self.mylistenport) self.session2 = Session(self.config2, ignore_singleton=True) # Allow session2 to start print >> sys.stderr, "test: downloader: Sleeping 3 secs to let Session2 start" time.sleep(3) tdef2 = TorrentDef.load(self.torrentfn) dscfg2 = DownloadStartupConfig() dscfg2.set_dest_dir(self.getDestDir(2)) dscfg2.set_video_event_callback(self.downloader_vod_ready_callback) d = self.session2.start_download(tdef2, dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(40) # To test if BITFIELD is indeed wrapping around. self.subtest_connect2downloader() time.sleep(80) def downloader_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: download:", dlstatus_strings[ds.get_status()], ds.get_progress() return (1.0, False) def downloader_vod_ready_callback(self, d, event, params): """ Called by SessionThread """ if event == VODEVENT_START: stream = params["stream"] while True: # Fake video playback data = stream.read(self.bitrate) if len(data) == 0: break time.sleep(1) def subtest_connect2downloader(self): print >> sys.stderr, "test: verifier: Connecting to seeder to check bitfield" infohash = self.tdef.get_infohash() s = BTConnection('localhost', self.mylistenport, user_infohash=infohash) s.read_handshake_medium_rare() try: s.s.settimeout(10.0) resp = s.recv() self.assert_(len(resp) > 0) print >> sys.stderr, "test: verifier: Got message", getMessageName(resp[0]) self.assert_(resp[0] == EXTEND) resp = s.recv() self.assert_(len(resp) > 0) print >> sys.stderr, "test: verifier: Got 2nd message", getMessageName(resp[0]) self.assert_(resp[0] == BITFIELD) b = Bitfield(self.npieces, resp[1:]) print >> sys.stderr, "test: verifier: Bitfield is", repr(b.toboollist()) b2 = Bitfield(self.npieces) b2[0] = True msg = BITFIELD + b2.tostring() s.send(msg) time.sleep(5) except socket.timeout: print >> sys.stderr, "test: verifier: Timeout, peer didn't reply" self.assert_(False) s.close()
def setUp(self): """ unittest test setup code """ self.setUpPreSession() self.session = Session(self.config) self.hisport = self.session.get_listen_port() self.setUpPostSession()
class TestSeeding(TestAsServer): """ Testing seeding via new tribler API: """ def setUp(self): """ override TestAsServer """ TestAsServer.setUp(self) self.session2 = None self.seeding_event = threading.Event() self.downloading_event = threading.Event() def setUpPreSession(self): """ override TestAsServer """ TestAsServer.setUpPreSession(self) self.config.set_libtorrent(True) self.config2 = self.config.copy() # not really necess self.config2.set_state_dir(self.getStateDir(2)) self.config2.set_listen_port(4810) self.dscfg2 = DownloadStartupConfig() self.dscfg2.set_dest_dir(self.getDestDir(2)) def setUpPostSession(self): pass def tearDown(self): if self.session2: self._shutdown_session(self.session2) time.sleep(10) TestAsServer.tearDown(self) def setup_seeder(self, merkle, filename='file.wmv'): self.tdef = TorrentDef() self.sourcefn = os.path.join(BASE_DIR, "API", filename) self.tdef.add_content(self.sourcefn) self.tdef.set_tracker("http://fake.net/announce") self.tdef.set_create_merkle_torrent(merkle) self.tdef.finalize() self.torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent") self.tdef.save(self.torrentfn) print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo['info']['name'] self.dscfg = DownloadStartupConfig() self.dscfg.set_dest_dir(os.path.join(BASE_DIR, "API")) # basedir of the file we are seeding d = self.session.start_download(self.tdef, self.dscfg) d.set_state_callback(self.seeder_state_callback) print >> sys.stderr, "test: setup_seeder: starting to wait for download to reach seeding state" assert self.seeding_event.wait(60) def seeder_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: seeder:", repr(d.get_def().get_name()), dlstatus_strings[ds.get_status()], ds.get_progress() if ds.get_status() == DLSTATUS_SEEDING: self.seeding_event.set() return (1.0, False) def test_normal_torrent(self): self.setup_seeder(False) self.subtest_is_seeding() self.subtest_download() # def test_merkle_torrent(self): # self.setup_seeder(True) # self.subtest_is_seeding() # self.subtest_download() def subtest_is_seeding(self): infohash = self.tdef.get_infohash() s = BTConnection('localhost', self.hisport, user_infohash=infohash) s.read_handshake_medium_rare() s.send(CHOKE) try: s.s.settimeout(10.0) resp = s.recv() self.assert_(len(resp) > 0) self.assert_(resp[0] == EXTEND) except socket.timeout: print >> sys.stderr, "test: Timeout, peer didn't reply" self.assert_(False) s.close() def subtest_download(self): """ Now download the file via another Session """ self.session2 = Session(self.config2, ignore_singleton=True) self.session2.start() time.sleep(5) tdef2 = TorrentDef.load(self.torrentfn) d = self.session2.start_download(tdef2, self.dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(5) d.add_peer(("127.0.0.1", self.hisport)) assert self.downloading_event.wait(60) def downloader_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: download:", repr(d.get_def().get_name()), dlstatus_strings[ds.get_status()], ds.get_progress() if ds.get_status() == DLSTATUS_SEEDING: # File is in destfn = os.path.join(self.getDestDir(2), "file.wmv") f = open(destfn, "rb") realdata = f.read() f.close() f = open(self.sourcefn, "rb") expdata = f.read() f.close() self.assert_(realdata == expdata) self.downloading_event.set() return (1.0, True) return (1.0, False)
class TestSeeding(TestAsServer): """ Testing seeding via new tribler API: """ def setUp(self): """ override TestAsServer """ TestAsServer.setUp(self) self.session2 = None self.seeding_event = threading.Event() self.downloading_event = threading.Event() def setUpPreSession(self): """ override TestAsServer """ TestAsServer.setUpPreSession(self) self.config.set_libtorrent(True) self.config2 = self.config.copy() # not really necess self.config2.set_state_dir(self.getStateDir(2)) self.config2.set_listen_port(4810) self.dscfg2 = DownloadStartupConfig() self.dscfg2.set_dest_dir(self.getDestDir(2)) def setUpPostSession(self): pass def tearDown(self): if self.session2: self._shutdown_session(self.session2) time.sleep(10) TestAsServer.tearDown(self) def setup_seeder(self, merkle, filename='file.wmv'): self.tdef = TorrentDef() self.sourcefn = os.path.join(BASE_DIR, "API", filename) self.tdef.add_content(self.sourcefn) self.tdef.set_tracker("http://fake.net/announce") self.tdef.set_create_merkle_torrent(merkle) self.tdef.finalize() self.torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent") self.tdef.save(self.torrentfn) print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo[ 'info']['name'] self.dscfg = DownloadStartupConfig() self.dscfg.set_dest_dir(os.path.join( BASE_DIR, "API")) # basedir of the file we are seeding d = self.session.start_download(self.tdef, self.dscfg) d.set_state_callback(self.seeder_state_callback) print >> sys.stderr, "test: setup_seeder: starting to wait for download to reach seeding state" assert self.seeding_event.wait(60) def seeder_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: seeder:", repr( d.get_def().get_name()), dlstatus_strings[ ds.get_status()], ds.get_progress() if ds.get_status() == DLSTATUS_SEEDING: self.seeding_event.set() return (1.0, False) def test_normal_torrent(self): self.setup_seeder(False) self.subtest_is_seeding() self.subtest_download() # def test_merkle_torrent(self): # self.setup_seeder(True) # self.subtest_is_seeding() # self.subtest_download() def subtest_is_seeding(self): infohash = self.tdef.get_infohash() s = BTConnection('localhost', self.hisport, user_infohash=infohash) s.read_handshake_medium_rare() s.send(CHOKE) try: s.s.settimeout(10.0) resp = s.recv() self.assert_(len(resp) > 0) self.assert_(resp[0] == EXTEND) except socket.timeout: print >> sys.stderr, "test: Timeout, peer didn't reply" self.assert_(False) s.close() def subtest_download(self): """ Now download the file via another Session """ self.session2 = Session(self.config2, ignore_singleton=True) self.session2.start() time.sleep(5) tdef2 = TorrentDef.load(self.torrentfn) d = self.session2.start_download(tdef2, self.dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(5) d.add_peer(("127.0.0.1", self.hisport)) assert self.downloading_event.wait(60) def downloader_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: download:", repr( d.get_def().get_name()), dlstatus_strings[ ds.get_status()], ds.get_progress() if ds.get_status() == DLSTATUS_SEEDING: # File is in destfn = os.path.join(self.getDestDir(2), "file.wmv") f = open(destfn, "rb") realdata = f.read() f.close() f = open(self.sourcefn, "rb") expdata = f.read() f.close() self.assert_(realdata == expdata) self.downloading_event.set() return (1.0, True) return (1.0, False)
class TestSeeding(TestAsServer): """ Testing seeding via new tribler API: """ def setUp(self): """ override TestAsServer """ TestAsServer.setUp(self) print >>sys.stderr,"test: Giving Session time to startup" time.sleep(5) print >>sys.stderr,"test: Session should have started up" def setUpPreSession(self): """ override TestAsServer """ TestAsServer.setUpPreSession(self) self.config.set_megacache(False) self.config.set_internal_tracker(True) #self.config.set_tracker_nat_check(0) self.mylistenport = 4810 def setUpPostSession(self): pass def setup_seeder(self,merkle): self.tdef = TorrentDef() self.sourcefn = os.path.join(os.getcwd(),"file.wmv") self.tdef.add_content(self.sourcefn) self.tdef.set_create_merkle_torrent(merkle) self.tdef.set_tracker(self.session.get_internal_tracker_url()) self.tdef.finalize() self.torrentfn = os.path.join(self.session.get_state_dir(),"gen.torrent") self.tdef.save(self.torrentfn) print >>sys.stderr,"test: setup_seeder: name is",self.tdef.metainfo['info']['name'] self.dscfg = DownloadStartupConfig() self.dscfg.set_dest_dir(os.getcwd()) d = self.session.start_download(self.tdef,self.dscfg) d.set_state_callback(self.seeder_state_callback) print >>sys.stderr,"test: Giving Download time to startup" time.sleep(5) def seeder_state_callback(self,ds): d = ds.get_download() print >>sys.stderr,"test: seeder:",`d.get_def().get_name()`,dlstatus_strings[ds.get_status()],ds.get_progress() return (1.0,False) def test_normal_torrent(self): """ I want to start a Tribler client once and then connect to it many times. So there must be only one test method to prevent setUp() from creating a new client every time. The code is constructed so unittest will show the name of the (sub)test where the error occured in the traceback it prints. """ self.setup_seeder(False) self.subtest_is_seeding() self.subtest_download() def test_merkle_torrent(self): self.setup_seeder(True) self.subtest_is_seeding() self.subtest_download() def subtest_is_seeding(self): infohash = self.tdef.get_infohash() print >> sys.stderr,"test: Connect to see if seeding this infohash" myid = '*' * 20 s = BTConnection('localhost',self.hisport,myid=myid,user_infohash=infohash) s.read_handshake_medium_rare() s.send(CHOKE) try: s.s.settimeout(10.0) print >> sys.stderr,"test: Receive to see if seeding this infohash" resp = s.recv() self.assert_(len(resp) > 0) self.assert_(resp[0] == EXTEND) except socket.timeout: print >> sys.stderr,"test: Timeout, peer didn't reply" self.assert_(False) s.close() def subtest_download(self): """ Now download the file via another Session """ self.config2 = self.config.copy() # not really necess self.config_path2 = tempfile.mkdtemp() self.config2.set_state_dir(self.config_path2) self.config2.set_listen_port(self.mylistenport) self.session2 = Session(self.config2,ignore_singleton=True) # Allow session2 to start print >>sys.stderr,"test: Sleeping 3 secs to let Session2 start" time.sleep(3) tdef2 = TorrentDef.load(self.torrentfn) dscfg2 = DownloadStartupConfig() dscfg2.set_dest_dir(self.config_path2) d = self.session2.start_download(tdef2,dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(20) def downloader_state_callback(self,ds): d = ds.get_download() print >>sys.stderr,"test: download:",`d.get_def().get_name()`,dlstatus_strings[ds.get_status()],ds.get_progress() if ds.get_status() == DLSTATUS_SEEDING: # File is in destfn = os.path.join(self.config_path2,"file.wmv") f = open(destfn,"rb") realdata = f.read() f.close() f = open(self.sourcefn,"rb") expdata = f.read() f.close() self.assert_(realdata == expdata) return (1.0,True) return (1.0,False)
from Tribler.Core.TorrentDef import * def states_callback(dslist): for ds in dslist: d = ds.get_download() print >> sys.stderr, "bctest 1: Stats", ` d.get_def().get_name( ) `, dlstatus_strings[ds.get_status()], ds.get_progress( ), "%", ds.get_error(), "up", ds.get_current_speed( UPLOAD), "down", ds.get_current_speed( DOWNLOAD), currentThread().getName() return (10.0, False) if __name__ == "__main__": sscfg = SessionStartupConfig() sscfg.set_state_dir('Session1') sscfg.set_overlay(1) sscfg.set_overlay_log('test.log') sscfg.set_superpeer_file('superpeer1.txt') sscfg.set_listen_port(7011) s = Session(sscfg) s.set_download_states_callback(states_callback, getpeerlist=False) tdef = TorrentDef.load('bla.torrent') d = s.start_download(tdef) time.sleep(3600 * 24 * 7)
class TestSeeding(TestAsServer): """ Testing seeding via new tribler API: """ def setUp(self): """ override TestAsServer """ TestAsServer.setUp(self) print >> sys.stderr, "test: Giving Session time to startup" time.sleep(5) print >> sys.stderr, "test: Session should have started up" def setUpPreSession(self): """ override TestAsServer """ TestAsServer.setUpPreSession(self) self.config.set_megacache(False) self.config.set_internal_tracker(True) #self.config.set_tracker_nat_check(0) self.mylistenport = 4810 def setUpPostSession(self): pass def setup_seeder(self, merkle): self.tdef = TorrentDef() self.sourcefn = os.path.join(os.getcwd(), "file.wmv") self.tdef.add_content(self.sourcefn) self.tdef.set_create_merkle_torrent(merkle) self.tdef.set_tracker(self.session.get_internal_tracker_url()) self.tdef.finalize() self.torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent") self.tdef.save(self.torrentfn) print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo[ 'info']['name'] self.dscfg = DownloadStartupConfig() self.dscfg.set_dest_dir(os.getcwd()) d = self.session.start_download(self.tdef, self.dscfg) d.set_state_callback(self.seeder_state_callback) print >> sys.stderr, "test: Giving Download time to startup" time.sleep(5) def seeder_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: seeder:", ` d.get_def().get_name( ) `, dlstatus_strings[ds.get_status()], ds.get_progress() return (1.0, False) def test_normal_torrent(self): """ I want to start a Tribler client once and then connect to it many times. So there must be only one test method to prevent setUp() from creating a new client every time. The code is constructed so unittest will show the name of the (sub)test where the error occured in the traceback it prints. """ self.setup_seeder(False) self.subtest_is_seeding() self.subtest_download() def test_merkle_torrent(self): self.setup_seeder(True) self.subtest_is_seeding() self.subtest_download() def subtest_is_seeding(self): infohash = self.tdef.get_infohash() print >> sys.stderr, "test: Connect to see if seeding this infohash" myid = '*' * 20 s = BTConnection('localhost', self.hisport, myid=myid, user_infohash=infohash) s.read_handshake_medium_rare() s.send(CHOKE) try: s.s.settimeout(10.0) print >> sys.stderr, "test: Receive to see if seeding this infohash" resp = s.recv() self.assert_(len(resp) > 0) self.assert_(resp[0] == EXTEND) except socket.timeout: print >> sys.stderr, "test: Timeout, peer didn't reply" self.assert_(False) s.close() def subtest_download(self): """ Now download the file via another Session """ self.config2 = self.config.copy() # not really necess self.config_path2 = tempfile.mkdtemp() self.config2.set_state_dir(self.config_path2) self.config2.set_listen_port(self.mylistenport) self.session2 = Session(self.config2, ignore_singleton=True) # Allow session2 to start print >> sys.stderr, "test: Sleeping 3 secs to let Session2 start" time.sleep(3) tdef2 = TorrentDef.load(self.torrentfn) dscfg2 = DownloadStartupConfig() dscfg2.set_dest_dir(self.config_path2) d = self.session2.start_download(tdef2, dscfg2) d.set_state_callback(self.downloader_state_callback) time.sleep(20) def downloader_state_callback(self, ds): d = ds.get_download() print >> sys.stderr, "test: download:", ` d.get_def().get_name( ) `, dlstatus_strings[ds.get_status()], ds.get_progress() if ds.get_status() == DLSTATUS_SEEDING: # File is in destfn = os.path.join(self.config_path2, "file.wmv") f = open(destfn, "rb") realdata = f.read() f.close() f = open(self.sourcefn, "rb") expdata = f.read() f.close() self.assert_(realdata == expdata) return (1.0, True) return (1.0, False)
class TestAsServer(AbstractServer): """ Parent class for testing the server-side of Tribler """ def setUp(self): self.setUpCleanup() self.setUpPreSession() self.quitting = False self.session = Session(self.config) 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_listen_port(random.randint(10000, 60000)) 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_swift_proc(False) self.config.set_mainline_dht(False) self.config.set_torrent_collecting(False) self.config.set_libtorrent(False) self.config.set_dht_torrent_collecting(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() print >> sys.stderr, "test_as_server: Number of threads still running", len(ts) for t in ts: print >> sys.stderr, "test_as_server: Thread still running", t.getName(), "daemon", t.isDaemon(), "instance:", t if SQLiteCacheDB.hasInstance(): SQLiteCacheDB.getInstance().close_all() SQLiteCacheDB.delInstance() self.tearDownCleanup() 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" print >> sys.stderr, "test_as_server: ONEXIT Waiting for Session to shutdown, will wait for an additional %d seconds" % (waittime - diff) time.sleep(1) print >> sys.stderr, "test_as_server: Session is shutdown" def assert_(self, boolean, reason=None, do_assert = True): if not boolean: self.quit() assert boolean, reason def startTest(self, callback): self.quitting = False callback() def Call(self, seconds, callback): if not self.quitting: if seconds: time.sleep(seconds) callback() def CallConditional(self, timeout, condition, callback, assertMsg=None): t = time.time() def DoCheck(): if not self.quitting: if time.time() - t < timeout: if condition(): print >> sys.stderr, "test_as_server: condition satisfied after %d seconds, calling callback" % (time.time() - t) callback() else: self.Call(0.5, DoCheck) else: print >> sys.stderr, "test_as_server: quitting, condition was not satisfied in %d seconds (%s)" % (timeout, assertMsg or "no-assert-msg") self.assert_(False, assertMsg if assertMsg else "Condition was not satisfied in %d seconds" % timeout, do_assert=False) self.Call(0, DoCheck) def quit(self): self.quitting = True