instrumentation/next-share/BaseLib/Test/test_sqlitecachedbhandler.py

   1 import os
   2 import sys
   3 import unittest
   4 from traceback import print_exc
   5 from time import time
   6 from binascii import unhexlify
   7 from shutil import copy as copyFile, move
   8
   9
  10 from BaseLib.Core.CacheDB.sqlitecachedb import SQLiteCacheDB, DEFAULT_BUSY_TIMEOUT,CURRENT_MAIN_DB_VERSION
  11 from bak_tribler_sdb import *
  12
  13 CREATE_SQL_FILE = os.path.join('..',"schema_sdb_v"+str(CURRENT_MAIN_DB_VERSION)+".sql")
  14
  15 import BaseLib.Core.CacheDB.sqlitecachedb
  16 print >>sys.stderr,"TEST: ENABLE DBUPGRADE HACK"
  17 BaseLib.Core.CacheDB.sqlitecachedb.TEST_SQLITECACHEDB_UPGRADE = True
  18
  19
  20 from BaseLib.Core.TorrentDef import TorrentDef
  21 from BaseLib.Core.CacheDB.sqlitecachedb import SQLiteCacheDB, bin2str, str2bin
  22 from BaseLib.Core.CacheDB.SqliteCacheDBHandler import TorrentDBHandler, MyPreferenceDBHandler, MyDBHandler, BasicDBHandler, PeerDBHandler, PreferenceDBHandler, SuperPeerDBHandler, FriendDBHandler, PopularityDBHandler
  23 from BaseLib.Category.Category import Category
  24 from bak_tribler_sdb import *
  25
  26 S_TORRENT_PATH_BACKUP = os.path.join(FILES_DIR, 'bak_single.torrent')
  27 S_TORRENT_PATH = os.path.join(FILES_DIR, 'single.torrent')
  28
  29 M_TORRENT_PATH_BACKUP = os.path.join(FILES_DIR, 'bak_multiple.torrent')
  30 M_TORRENT_PATH = os.path.join(FILES_DIR, 'multiple.torrent')
  31
  32 BUSYTIMEOUT = 5000
  33 SHOW_NOT_TESTED_FUNCTIONS = False    # Enable this to show the functions not tested yet
  34
  35 def init():
  36     init_bak_tribler_sdb()
  37
  38     SQLiteCacheDB.getInstance().initDB(TRIBLER_DB_PATH, busytimeout=BUSYTIMEOUT)
  39     TorrentDBHandler.getInstance().register(Category.getInstance('..'),'.')
  40
  41
  42 def getFuncs2Test(calss_name):
  43     return filter(lambda s:s != 'lock' and not s.startswith('__') and s not in dir(BasicDBHandler), dir(calss_name))
  44
  45 SQLiteCacheDB.DEBUG = False
  46
  47
  48 class TestSqliteBasicDBHandler(unittest.TestCase):
  49
  50     def setUp(self):
  51         db_path = TRIBLER_DB_PATH
  52         self.sqlitedb = SQLiteCacheDB.getInstance()
  53         self.sqlitedb.initDB(db_path, busytimeout=BUSYTIMEOUT)
  54
  55     def tearDown(self):
  56         SQLiteCacheDB.getInstance().close()
  57
  58     def singtest_size(self):
  59         table_name = 'Peer'
  60         db = BasicDBHandler(self.sqlitedb,table_name)
  61         size = db.size()
  62         assert size == 3995,size
  63
  64     def singtest_getOne(self):
  65         table_name = 'Peer'
  66         db = BasicDBHandler(self.sqlitedb,table_name)
  67
  68         ip = db.getOne('ip', peer_id=1)
  69         assert ip == '1.1.1.1', ip
  70
  71         pid = db.getOne('peer_id', ip='1.1.1.1')
  72         assert pid == 1, pid
  73
  74         name = db.getOne('name', ip='1.1.1.1', port=1)
  75         assert name == 'Peer 1', name
  76
  77         name = db.getOne('name', ip='68.108.115.221', port=6882)
  78         assert name == None, name
  79
  80         tid = db.getOne('peer_id', conj='OR', ip='1.1.1.1', name='Peer 1')
  81         assert tid == 1, tid
  82
  83         tid = db.getOne('peer_id', conj='OR', ip='1.1.1.1', name='asdfasfasfXXXXXXxx...')
  84         assert tid == 1, tid
  85
  86         tid = db.getOne('peer_id', conj='OR', ip='1.1.1.123', name='Peer 1')
  87         assert tid == 1, tid
  88
  89         lbt = db.getOne('last_buddycast', peer_id=1)
  90         assert lbt == 1193379432, lbt
  91
  92         name, ip, lbt = db.getOne(('name','ip','last_buddycast'), peer_id=1)
  93         assert name == 'Peer 1' and ip == '1.1.1.1' and lbt == 1193379432, (name, ip, lbt)
  94
  95         values = db.getOne('*', peer_id=1)
  96         # 03/02/10 Boudewijn: In contrast to the content of the
  97         # database, the similarity value is not 12.537961593122299 but
  98         # 0 because it is reset as the database is upgraded.
  99         results = (1, u'MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEAAA6SYI4NHxwQ8P7P8QXgWAP+v8SaMVzF5+fSUHdAMrs6NvL5Epe1nCNSdlBHIjNjEiC5iiwSFZhRLsr', u'Peer 1', u'1.1.1.1', 1, None, 2, 0, 0, 0, 1194966306, 1193379769, 1193379432, 1, 1, 0, 0, 0, 0, 0)
 100
 101         for i in range(len(values)):
 102             assert values[i] == results[i], (i, values[i], results[i])
 103
 104     def singtest_getAll(self):
 105         table_name = 'Peer'
 106         db = BasicDBHandler(self.sqlitedb,table_name)
 107
 108         ips = db.getAll('ip')
 109         assert len(ips) == 3995, len(ips)
 110
 111         ips = db.getAll('distinct ip')
 112         assert len(ips) == 256, len(ips)
 113
 114         ips = db.getAll('ip', "ip like '130.%'")
 115         assert len(ips) == 16, len(ips)
 116
 117         ids = db.getAll('peer_id', 'thumbnail is NULL')
 118         assert len(ids) == 3995, len(ids)
 119
 120         ips = db.getAll('ip', "ip like '88.%'", port=88, conj='or')
 121         assert len(ips) == 16, len(ips)
 122
 123         ips = db.getAll('ip', "ip like '88.%'", port=88, order_by='ip')
 124         assert len(ips) == 1, len(ips)
 125         assert ips[0][0] == '88.88.88.88', ips[0]
 126
 127         names = db.getAll('name', "ip like '88.%'", order_by='ip', limit=4, offset=1)
 128         assert len(names) == 4
 129         assert names[2][0] == 'Peer 856', names
 130         # select name from Peer where ip like '88.%' and port==7762 order by ip limit 4 offset 3
 131
 132         ips = db.getAll('count(distinct ip), port', group_by='port')
 133         # select count(distinct ip), port from Peer group by port
 134         for nip, port in ips:
 135             if port == 6881:
 136                 assert nip == 2842, nip
 137                 break
 138
 139
 140 class TestSqliteMyDBHandler(unittest.TestCase):
 141
 142     def setUp(self):
 143         db_path = TRIBLER_DB_PATH
 144         db = SQLiteCacheDB.getInstance()
 145         db.openDB(db_path, busytimeout=BUSYTIMEOUT)
 146
 147     def tearDown(self):
 148         SQLiteCacheDB.getInstance().close()
 149
 150     def singtest_get(self):
 151         db = MyDBHandler.getInstance()
 152         value = db.get('version')
 153         assert value == str(CURRENT_MAIN_DB_VERSION), value
 154
 155     def singtest_put(self):
 156         db = MyDBHandler.getInstance()
 157         new_ip = '127.0.0.1'
 158         db.put('ip', new_ip)
 159         value = db.get('ip')
 160         assert value == new_ip, value
 161
 162         new_ip = ''
 163         db.put('ip', new_ip)
 164         value = db.get('ip')
 165         assert value == new_ip, (value, new_ip)
 166
 167 class TestSuperPeerDBHandler(unittest.TestCase):
 168
 169     def setUp(self):
 170         db_path = TRIBLER_DB_PATH
 171         db = SQLiteCacheDB.getInstance()
 172         db.openDB(db_path, busytimeout=BUSYTIMEOUT)
 173         self.sp1 = '0R0\x10\x06\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04\x00\\\xdfXv\xffX\xf2\xfe\x96\xe1_]\xf5\x1b\xb4\x91\x91\xa5I\xf0nl\x81\xd2A\xfb\xb7u)\x01T\xa9*)r\x9b\x81s\xb7j\xd2\xecrSg$;\xc8"7s\xecSF\xd3\x0bgK\x1c'
 174         self.sp2 = '0R0\x10\x06\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04\x01\xdb\x80+O\xd9N7`\xfc\xd3\xdd\xf0 \xfdC^\xc9\xd7@\x97\xaa\x91r\x1c\xdeL\xf2n\x9f\x00U\xc1A\xf9Ae?\xd8t}_c\x08\xb3G\xf8g@N! \xa0\x90M\xfb\xca\xcfZ@'
 175
 176     def tearDown(self):
 177         s = SQLiteCacheDB.getInstance()
 178         s.close()
 179
 180     def _test_size(self):
 181         db = SuperPeerDBHandler.getInstance()
 182         size = db.size()
 183         assert size == 8, size
 184
 185     def _test_getSuperPeerList(self):
 186         db = SuperPeerDBHandler.getInstance()
 187         sps = db.getSuperPeers()
 188         assert self.sp1 in sps
 189         assert self.sp2 in sps
 190
 191     def singtest_setSuperPeer(self):
 192         db = SuperPeerDBHandler.getInstance()
 193
 194         sps = db.getSuperPeers()
 195         assert len(sps) == 8, len(sps)
 196
 197         db.peer_db_handler.addPeer(self.sp1, {'superpeer':0})
 198         sps = db.getSuperPeers()
 199         assert self.sp1 not in sps
 200         assert len(sps) == 7, len(sps)
 201
 202         db.peer_db_handler.addPeer(self.sp1, {'superpeer':0})
 203         sps = db.getSuperPeers()
 204         assert self.sp1 not in sps
 205         assert len(sps) == 7
 206
 207         db.peer_db_handler.addPeer(self.sp1, {'superpeer':1})
 208         sps = db.getSuperPeers()
 209         assert self.sp1 in sps
 210         assert len(sps) == 8
 211
 212         db.peer_db_handler.addPeer(self.sp1, {'superpeer':1})
 213         sps = db.getSuperPeers()
 214         assert self.sp1 in sps
 215         assert len(sps) == 8
 216
 217     def singtest_addExternalSuperPeer(self):
 218         fake_permid_x = 'fake_permid_x'+'0R0\x10\x06\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 219         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234, 'name':'fake peer x'}
 220         db = SuperPeerDBHandler.getInstance()
 221         db.addExternalSuperPeer(peer_x)
 222         sps = db.getSuperPeers()
 223         assert fake_permid_x in sps
 224         assert len(sps) == 9, len(sps)
 225
 226         db.addExternalSuperPeer(peer_x)
 227         sps = db.getSuperPeers()
 228         assert fake_permid_x in sps
 229         assert len(sps) == 9, len(sps)
 230
 231         db._db.deletePeer(fake_permid_x, force=True)
 232         sps = db.getSuperPeers()
 233         assert fake_permid_x not in sps
 234         assert len(sps) == 8, len(sps)
 235
 236         db._db.deletePeer(fake_permid_x, force=True)
 237         sps = db.getSuperPeers()
 238         assert fake_permid_x not in sps
 239         assert len(sps) == 8, len(sps)
 240
 241 class TestFriendDBHandler(unittest.TestCase):
 242
 243     def setUp(self):
 244         db_path = TRIBLER_DB_PATH
 245         db = SQLiteCacheDB.getInstance()
 246         db.openDB(db_path, busytimeout=BUSYTIMEOUT)
 247         self.sp1 = '0R0\x10\x06\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04\x00\\\xdfXv\xffX\xf2\xfe\x96\xe1_]\xf5\x1b\xb4\x91\x91\xa5I\xf0nl\x81\xd2A\xfb\xb7u)\x01T\xa9*)r\x9b\x81s\xb7j\xd2\xecrSg$;\xc8"7s\xecSF\xd3\x0bgK\x1c'
 248         self.sp2 = '0R0\x10\x06\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04\x01\xdb\x80+O\xd9N7`\xfc\xd3\xdd\xf0 \xfdC^\xc9\xd7@\x97\xaa\x91r\x1c\xdeL\xf2n\x9f\x00U\xc1A\xf9Ae?\xd8t}_c\x08\xb3G\xf8g@N! \xa0\x90M\xfb\xca\xcfZ@'
 249         self.fr1 = str2bin('MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEAL/l2IyVa6lc3KAqQyEnR++rIzi+AamnbzXHCxOFAFy67COiBhrC79PLzzUiURbHDx21QA4p8w3UDHLA')
 250
 251     def tearDown(self):
 252         SQLiteCacheDB.getInstance().close()
 253
 254     def singtest_size(self):
 255         db = FriendDBHandler.getInstance()
 256         size = db.size()
 257         assert size == 2, size
 258
 259     def singtest_getFriends(self):
 260         db = FriendDBHandler.getInstance()
 261         friends = db.getFriends()
 262         assert self.sp1 not in friends
 263         assert self.fr1 in friends
 264
 265     def singtest_setFriendState(self):
 266         db = FriendDBHandler.getInstance()
 267         db.setFriendState(self.sp1)
 268         assert db.getFriendState(self.sp1)
 269         sps = db.getFriends()
 270         assert self.sp1 in sps
 271         assert len(sps) == 3
 272
 273         db.setFriendState(self.sp1)
 274         assert db.getFriendState(self.sp1)
 275         sps = db.getFriends()
 276         assert self.sp1 in sps
 277         assert len(sps) == 3
 278
 279         db.deleteFriend(self.sp1)
 280         assert not db.getFriendState(self.sp1)
 281         sps = db.getFriends()
 282         assert self.sp1 not in sps
 283         assert len(sps) == 2
 284
 285         db.deleteFriend(self.sp1)
 286         assert not db.getFriendState(self.sp1)
 287         sps = db.getFriends()
 288         assert self.sp1 not in sps
 289         assert len(sps) == 2
 290
 291     def singtest_addExternalFriend(self):
 292         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 293         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234, 'name':'fake peer x'}
 294         db = FriendDBHandler.getInstance()
 295         db.addExternalFriend(peer_x)
 296         sps = db.getFriends()
 297         assert fake_permid_x in sps
 298         assert len(sps) == 3, len(sps)
 299
 300         db.addExternalFriend(peer_x)
 301         sps = db.getFriends()
 302         assert fake_permid_x in sps
 303         assert len(sps) == 3, len(sps)
 304
 305         db._db.deletePeer(fake_permid_x, force=True)
 306         sps = db.getFriends()
 307         assert fake_permid_x not in sps
 308         assert len(sps) == 2, len(sps)
 309
 310         db._db.deletePeer(fake_permid_x, force=True)
 311         sps = db.getFriends()
 312         assert fake_permid_x not in sps
 313         assert len(sps) == 2, len(sps)
 314
 315
 316 class TestSqlitePeerDBHandler(unittest.TestCase):
 317
 318     def setUp(self):
 319         db_path = TRIBLER_DB_PATH
 320         db = SQLiteCacheDB.getInstance()
 321         db.openDB(db_path, busytimeout=BUSYTIMEOUT)
 322         self.sp1 = '0R0\x10\x06\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04\x00\\\xdfXv\xffX\xf2\xfe\x96\xe1_]\xf5\x1b\xb4\x91\x91\xa5I\xf0nl\x81\xd2A\xfb\xb7u)\x01T\xa9*)r\x9b\x81s\xb7j\xd2\xecrSg$;\xc8"7s\xecSF\xd3\x0bgK\x1c'
 323         self.sp2 = '0R0\x10\x06\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04\x01\xdb\x80+O\xd9N7`\xfc\xd3\xdd\xf0 \xfdC^\xc9\xd7@\x97\xaa\x91r\x1c\xdeL\xf2n\x9f\x00U\xc1A\xf9Ae?\xd8t}_c\x08\xb3G\xf8g@N! \xa0\x90M\xfb\xca\xcfZ@'
 324         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 325         hp = db.hasPeer(fake_permid_x)
 326         assert not hp
 327
 328     def tearDown(self):
 329         SQLiteCacheDB.getInstance().close()
 330
 331     def singtest_getList(self):
 332         db = PeerDBHandler.getInstance()
 333         sp1 = db.getPeer(self.sp1)
 334         sp2 = db.getPeer(self.sp2)
 335         assert isinstance(sp1, dict)
 336         assert isinstance(sp2, dict)
 337         print >>sys.stderr,"singtest_GETLIST SP1",`sp1`
 338         print >>sys.stderr,"singtest_GETLIST SP1",`sp2`
 339         assert sp1['port'] == 628
 340         assert sp2['port'] == 3287
 341
 342     def singtest_getPeerSim(self):
 343         db = PeerDBHandler.getInstance()
 344         permid_str = 'MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEACPJqLjmKeMNRwkCNKkPH51gjQ5e7u4s2vWv9I/AALXtpf+bFPtY8cyFv6OCzisYDo+brgqOxAtuNZwP'
 345         permid = str2bin(permid_str)
 346         sim = db.getPeerSim(permid)
 347         # 03/02/10 Boudewijn: In contrast to the content of the
 348         # database, the similarity value is not 5.82119645394964 but 0
 349         # because it is reset as the database is upgraded.
 350         assert sim == 0
 351
 352         permid_str = 'MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEAAB0XbUrw5b8CrTrMZST1SPyrzjgSzIE6ynALtlZASGAb+figVXRRGpKW6MSal3KnEm1/q0P3JPWrhCE'
 353         permid = str2bin(permid_str)
 354         sim = db.getPeerSim(permid)
 355         assert sim == 0
 356
 357     def singtest_getPeerList(self):
 358         db = PeerDBHandler.getInstance()
 359         peerlist = db.getPeerList()
 360         assert len(peerlist) == 3995
 361         peerlist.sort()
 362         assert bin2str(peerlist[345]) == 'MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEACxVRvG/Gr19EAPJru2Z5gjctEzv973/PJCQIua2ATMP6euq+Kf4gYpdKbsB/PWqJnfY/wSKPHHfIByV'
 363
 364     def singtest_getPeers(self):
 365         db = PeerDBHandler.getInstance()
 366         peerlist = db.getPeerList()
 367         peerlist.sort()
 368         pl = peerlist[:10]
 369         peers = db.getPeers(pl, ['permid', 'peer_id', 'ip', 'port', 'name'])
 370         #for p in peers: print p
 371         assert peers[7]['name'] == 'Peer 7'
 372         assert peers[8]['name'] == 'Peer 8'
 373         assert peers[1]['ip'] == '1.1.1.1'
 374         assert peers[3]['peer_id'] == 3
 375
 376     def singtest_addPeer(self):
 377         db = PeerDBHandler.getInstance()
 378         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 379         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234,
 380                   'name':'fake peer x', 'last_seen':12345}
 381         oldsize = db.size()
 382         db.addPeer(fake_permid_x, peer_x)
 383         assert db.size() == oldsize+1, (db.size(), oldsize+1)
 384         #db.addPeer(fake_permid_x, peer_x)
 385         #assert db.size() == oldsize+1
 386         p = db.getPeer(fake_permid_x)
 387         assert p['ip'] == '1.2.3.4'
 388         assert p['port'] == 234
 389         assert p['name'] == 'fake peer x'
 390 #        dns = db.getPeer(fake_permid_x, ('ip','port'))
 391 #        assert dns[0] == '1.2.3.4'
 392 #        assert dns[1] == 234
 393 #        dns = db.getPeer(fake_permid_x+'abcd', ('ip','port'))
 394 #        assert dns == None
 395
 396         peer_x['ip'] = '4.3.2.1'
 397         peer_x['port'] = 432
 398         peer_x['last_seen'] = 1234567
 399         db.addPeer(fake_permid_x, peer_x, update_dns=False)
 400         p = db.getPeer(fake_permid_x)
 401         assert p['ip'] == '1.2.3.4'
 402         assert p['port'] == 234
 403         assert p['last_seen'] == 1234567, p['last_seen']
 404
 405         peer_x['ip'] = '4.3.2.1'
 406         peer_x['port'] = 432
 407         peer_x['last_seen'] = 12345
 408         db.addPeer(fake_permid_x, peer_x, update_dns=True)
 409         p = db.getPeer(fake_permid_x)
 410         assert p['ip'] == '4.3.2.1'
 411         assert p['port'] == 432
 412         assert p['last_seen'] == 12345
 413
 414         peer_x['ip'] = '1.2.3.1'
 415         peer_x['port'] = 234
 416         db.addPeer(fake_permid_x, peer_x, update_dns=False)
 417         p = db.getPeer(fake_permid_x)
 418         assert p['ip'] == '4.3.2.1'
 419         assert p['port'] == 432
 420         assert p['last_seen'] == 12345
 421
 422         peer_x['ip'] = '1.2.3.4'
 423         peer_x['port'] = 234
 424         peer_x['last_seen'] = 1234569
 425         db.addPeer(fake_permid_x, peer_x, update_dns=True)
 426         p = db.getPeer(fake_permid_x)
 427         assert p['ip'] == '1.2.3.4'
 428         assert p['port'] == 234
 429         assert p['last_seen'] == 1234569
 430
 431         peer_x['ip'] = '1.2.3.5'
 432         peer_x['port'] = 236
 433         db.addPeer(fake_permid_x, peer_x, update_dns=True)
 434         p = db.getPeer(fake_permid_x)
 435         assert p['ip'] == '1.2.3.5'
 436         assert p['port'] == 236
 437
 438         db._db.deletePeer(fake_permid_x, force=True)
 439         p = db.getPeer(fake_permid_x)
 440         assert p == None
 441         assert db.size() == oldsize
 442
 443     def singtest_aa_hasPeer(self):
 444         db = PeerDBHandler.getInstance()
 445         assert db.hasPeer(self.sp1)
 446         assert db.hasPeer(self.sp2)
 447         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 448         assert not db.hasPeer(fake_permid_x)
 449
 450     def singtest_findPeers(self):
 451         db = PeerDBHandler.getInstance()
 452         find_list = db.findPeers('ip', '88.88.88.88')
 453         assert len(find_list) == 16
 454
 455         find_list = db.findPeers('ip', '1.2.3.4')
 456         assert len(find_list) == 0
 457
 458         db = PeerDBHandler.getInstance()
 459         find_list = db.findPeers('permid', self.sp1)
 460         assert len(find_list) == 1 and find_list[0]['permid'] == self.sp1
 461         #assert len(find_list) == 3 and 901 in find_list
 462
 463     def singtest_updatePeer(self):
 464         db = PeerDBHandler.getInstance()
 465         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 466         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234,
 467                   'name':'fake peer x', 'last_seen':12345}
 468         oldsize = db.size()
 469         db.addPeer(fake_permid_x, peer_x)
 470         assert db.size() == oldsize+1, (db.size(), oldsize+1)
 471         p = db.getPeer(fake_permid_x)
 472         assert p['ip'] == '1.2.3.4'
 473         assert p['port'] == 234
 474         assert p['name'] == 'fake peer x'
 475
 476         db.updatePeer(fake_permid_x, ip='4.3.2.1')
 477         db.updatePeer(fake_permid_x, port=432)
 478         db.updatePeer(fake_permid_x, last_seen=1234567)
 479         p = db.getPeer(fake_permid_x)
 480         assert p['ip'] == '4.3.2.1'
 481         assert p['port'] == 432
 482         assert p['last_seen'] == 1234567
 483
 484         db._db.deletePeer(fake_permid_x, force=True)
 485         p = db.getPeer(fake_permid_x)
 486         assert p == None
 487         assert db.size() == oldsize
 488
 489     def singtest_deletePeer(self):
 490         db = PeerDBHandler.getInstance()
 491         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 492         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234,
 493                   'name':'fake peer x', 'last_seen':12345, 'friend':1, 'superpeer':0}
 494         oldsize = db.size()
 495         p = db.getPeer(fake_permid_x)
 496         assert p == None, p
 497
 498         db.addPeer(fake_permid_x, peer_x)
 499         assert db.size() == oldsize+1, (db.size(), oldsize+1)
 500         assert db.hasPeer(fake_permid_x)
 501         p = db.getPeer(fake_permid_x)
 502         assert p != None
 503
 504         db.deletePeer(fake_permid_x, force=False)
 505         assert db.hasPeer(fake_permid_x)
 506
 507         db.deletePeer(fake_permid_x, force=True)
 508         assert db.size() == oldsize
 509         assert not db.hasPeer(fake_permid_x)
 510
 511         p = db.getPeer(fake_permid_x)
 512         assert p == None
 513
 514         db.deletePeer(fake_permid_x, force=True)
 515         assert db.size() == oldsize
 516
 517         p = db.getPeer(fake_permid_x)
 518         assert p == None, p
 519
 520         db.deletePeer(fake_permid_x, force=True)
 521         assert db.size() == oldsize
 522
 523     def singtest_updateTimes(self):
 524         db = PeerDBHandler.getInstance()
 525         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 526         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234,
 527                   'name':'fake peer x', 'last_seen':12345, 'connected_times':3}
 528         oldsize = db.size()
 529         p = db.getPeer(fake_permid_x)
 530         assert p == None, p
 531
 532         db.addPeer(fake_permid_x, peer_x)
 533         assert db.hasPeer(fake_permid_x)
 534         assert db.size() == oldsize+1, (db.size(), oldsize+1)
 535
 536         db.updateTimes(fake_permid_x, 'connected_times')
 537         sql = 'select connected_times from Peer where permid='+repr(bin2str(fake_permid_x))
 538         ct = db._db.fetchone(sql)
 539         assert ct == 4, ct
 540
 541         db.updateTimes(fake_permid_x, 'buddycast_times')
 542         sql = 'select buddycast_times from Peer where permid='+repr(bin2str(fake_permid_x))
 543         ct = db._db.fetchone(sql)
 544         assert ct == 1, ct
 545
 546         db.updateTimes(fake_permid_x, 'buddycast_times', 3)
 547         sql = 'select buddycast_times from Peer where permid='+repr(bin2str(fake_permid_x))
 548         ct = db._db.fetchone(sql)
 549         assert ct == 4, ct
 550
 551         db.deletePeer(fake_permid_x, force=True)
 552         assert not db.hasPeer(fake_permid_x)
 553
 554     def singtest_getPermIDByIP(self):
 555         db = PeerDBHandler.getInstance()
 556         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 557         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234,
 558                   'name':'fake peer x', 'last_seen':12345, 'connected_times':3}
 559         oldsize = db.size()
 560         p = db.getPeer(fake_permid_x)
 561         assert p == None, p
 562
 563         db.addPeer(fake_permid_x, peer_x)
 564         assert db.hasPeer(fake_permid_x)
 565         assert db.size() == oldsize+1, (db.size(), oldsize+1)
 566
 567         permid = db.getPermIDByIP('1.2.3.4')
 568         assert bin2str(permid) == bin2str(fake_permid_x)
 569
 570         db.deletePeer(fake_permid_x, force=True)
 571         assert not db.hasPeer(fake_permid_x)
 572         assert db.size() == oldsize
 573
 574     def singtest_loadPeers(self):
 575         db = PeerDBHandler.getInstance()
 576         peer_size = db.size()
 577         res = db.getGUIPeers()
 578         assert len(res) == 1477, len(res)
 579         data = res[0]
 580         p = db.getPeer(data['permid'])
 581         assert p['name'] == data['name']
 582         assert 70 < len(data['permid']) < 90    # must be binary
 583
 584 class TestPreferenceDBHandler(unittest.TestCase):
 585
 586     def setUp(self):
 587         db_path = TRIBLER_DB_PATH
 588         db = SQLiteCacheDB.getInstance()
 589         db.openDB(db_path, busytimeout=BUSYTIMEOUT)
 590
 591     def tearDown(self):
 592         SQLiteCacheDB.getInstance().close()
 593
 594     def singtest_getPrefList(self):
 595         db = PreferenceDBHandler.getInstance()
 596         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 597         pl = db.getPrefList(fake_permid_x)
 598         assert pl == [], pl
 599
 600         truth = {3127:235, 994:20, 19:1, 5:0}
 601         permid = {}
 602         permid[3127] = 'MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEAcPezgQ13k1MSOaUrCPisWRhYuNT7Tm+q5rUgHFvAWd9b+BcSut6TCniEgHYHDnQ6TH/vxQBqtY8Loag'
 603         permid[994] = 'MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEAJUNmwvDaigRaM4cj7cE2O7lessqnnFEQsan7df9AZS8xeNmVsP/XXVrEt4t7e2TNicYmjn34st/sx2P'
 604         permid[19] = 'MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEAAJv2YLuIWa4QEdOEs4CPRxQZDwZphKd/xK/tgbcALG198nNdT10znJ2sZYl+OJIvj7YfYp75PrrnWNX'
 605         permid[5] = 'MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEAAB0XbUrw5b8CrTrMZST1SPyrzjgSzIE6ynALtlZASGAb+figVXRRGpKW6MSal3KnEm1/q0P3JPWrhCE'
 606
 607         for pid in truth:
 608             pl = db.getPrefList(str2bin(permid[pid]))
 609             assert len(pl) == truth[pid], [pid, len(pl)]
 610
 611     def singtest_addPreference(self):
 612         db = PeerDBHandler.getInstance()
 613         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 614         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234,
 615                   'name':'fake peer x', 'last_seen':12345, 'connected_times':3}
 616         oldsize = db.size()
 617         oldinfohash_size = db._db.size('Torrent')
 618         p = db.getPeer(fake_permid_x)
 619         assert p == None, p
 620
 621         db.addPeer(fake_permid_x, peer_x)
 622         assert db.hasPeer(fake_permid_x)
 623         assert db.size() == oldsize+1, (db.size(), oldsize+1)
 624
 625         # fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00\x07*\x86H\xce=\x02'
 626         # fake_infoahsh2 = 'fake_infohash_2'+'0R0\x10\x00\x07*\x86H\xce=\x02'
 627         # 02/02/10 Boudewijn: infohashes must be 20 bytes long
 628         fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00'
 629         fake_infoahsh2 = 'fake_infohash_2'+'0R0\x10\x00'
 630         prefdb = PreferenceDBHandler.getInstance()
 631         oldpref_size = prefdb.size()
 632         prefdb.addPreference(fake_permid_x, fake_infoahsh)
 633         prefdb.addPreference(fake_permid_x, fake_infoahsh2)
 634         assert prefdb.size() == oldpref_size + 2
 635         assert oldinfohash_size + 2 == db._db.size('Torrent'), (oldinfohash_size + 2, db._db.size('Torrent'))
 636
 637         pl = prefdb.getPrefList(fake_permid_x, return_infohash=True)
 638         assert len(pl) == 2
 639         assert fake_infoahsh in pl
 640         assert fake_infoahsh2 in pl
 641
 642         pl = prefdb.getPrefList(fake_permid_x, return_infohash=True)
 643         assert len(pl) == 2, pl
 644         assert fake_infoahsh in pl
 645         assert fake_infoahsh2 in pl
 646         prefdb._deletePeer(fake_permid_x)
 647         pl = prefdb.getPrefList(fake_permid_x)
 648         assert pl == []
 649         assert prefdb.size() == oldpref_size, (prefdb.size(), oldpref_size)
 650
 651         db.deletePeer(fake_permid_x, force=True)
 652         assert not db.hasPeer(fake_permid_x)
 653         assert db.size() == oldsize
 654
 655         # add again
 656         db.addPeer(fake_permid_x, peer_x)
 657         assert db.hasPeer(fake_permid_x)
 658         assert db.size() == oldsize+1
 659
 660         prefdb.addPreference(fake_permid_x, fake_infoahsh)
 661         prefdb.addPreference(fake_permid_x, fake_infoahsh2)
 662         assert prefdb.size() == oldpref_size + 2
 663         assert oldinfohash_size + 2 == db._db.size('Torrent')
 664
 665         pl = prefdb.getPrefList(fake_permid_x, return_infohash=True)
 666         assert len(pl) == 2
 667         assert fake_infoahsh in pl
 668         assert fake_infoahsh2 in pl
 669
 670         db.deletePeer(fake_permid_x, force=True)
 671         assert not db.hasPeer(fake_permid_x)
 672         assert db.size() == oldsize
 673         pl = prefdb.getPrefList(fake_permid_x)
 674         assert pl == []
 675         assert prefdb.size() == oldpref_size, (prefdb.size(), oldpref_size)
 676
 677         db._db.deleteInfohash(fake_infoahsh)
 678         db._db.deleteInfohash(fake_infoahsh2)
 679         tid = db._db.getTorrentID(fake_infoahsh)
 680         assert tid is None
 681         tid = db._db.getTorrentID(fake_infoahsh2)
 682         assert tid is None
 683         assert oldinfohash_size == db._db.size('Torrent'), [oldinfohash_size, db._db.size('Torrent')]
 684
 685     def singtest_addPeerPreferences(self):
 686         db = PeerDBHandler.getInstance()
 687         fake_permid_x = 'fake_permid_x'+'0R0\x10\x00\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\x1a\x03>\x00\x04'
 688         peer_x = {'permid':fake_permid_x, 'ip':'1.2.3.4', 'port':234,
 689                   'name':'fake peer x', 'last_seen':12345, 'connected_times':3}
 690         oldsize = db.size()
 691         oldinfohash_size = db._db.size('Torrent')
 692         p = db.getPeer(fake_permid_x)
 693         assert p == None, p
 694
 695         db.addPeer(fake_permid_x, peer_x)
 696         assert db.hasPeer(fake_permid_x)
 697         assert db.size() == oldsize+1, (db.size(), oldsize+1)
 698
 699         # fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00\x07*\x86H\xce=\x02'
 700         # fake_infoahsh2 = 'fake_infohash_2'+'0R0\x10\x00\x07*\x86H\xce=\x02'
 701         # 02/02/10 Boudewijn: infohashes must be 20 bytes long
 702         fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00'
 703         fake_infoahsh2 = 'fake_infohash_2'+'0R0\x10\x00'
 704         fi = [fake_infoahsh,fake_infoahsh2]
 705         prefdb = PreferenceDBHandler.getInstance()
 706         oldpref_size = prefdb.size()
 707         prefdb.addPreferences(fake_permid_x, fi)
 708         assert prefdb.size() == oldpref_size + 2, [prefdb.size(), oldpref_size]
 709         assert oldinfohash_size + 2 == db._db.size('Torrent')
 710
 711         pl = prefdb.getPrefList(fake_permid_x, return_infohash=True)
 712         assert len(pl) == 2
 713         assert fake_infoahsh in pl, (fake_infoahsh, pl)
 714         assert fake_infoahsh2 in pl, (fake_infoahsh2, pl)
 715
 716         pl = prefdb.getPrefList(fake_permid_x, return_infohash=True)
 717         assert len(pl) == 2, pl
 718         assert fake_infoahsh in pl
 719         assert fake_infoahsh2 in pl
 720         prefdb._deletePeer(fake_permid_x)
 721         pl = prefdb.getPrefList(fake_permid_x, return_infohash=True)
 722         assert pl == []
 723         assert prefdb.size() == oldpref_size, (prefdb.size(), oldpref_size)
 724
 725         db.deletePeer(fake_permid_x, force=True)
 726         assert not db.hasPeer(fake_permid_x)
 727         assert db.size() == oldsize
 728
 729         # add again
 730         db.addPeer(fake_permid_x, peer_x)
 731         assert db.hasPeer(fake_permid_x)
 732         assert db.size() == oldsize+1
 733
 734         prefdb.addPreferences(fake_permid_x, fi)
 735         assert prefdb.size() == oldpref_size + 2
 736         assert oldinfohash_size + 2 == db._db.size('Torrent')
 737
 738         pl = prefdb.getPrefList(fake_permid_x, return_infohash=True)
 739         assert len(pl) == 2
 740         assert fake_infoahsh in pl
 741         assert fake_infoahsh2 in pl
 742
 743         db.deletePeer(fake_permid_x, force=True)
 744         assert not db.hasPeer(fake_permid_x)
 745         assert db.size() == oldsize
 746         pl = prefdb.getPrefList(fake_permid_x)
 747         assert pl == []
 748         assert prefdb.size() == oldpref_size, (prefdb.size(), oldpref_size)
 749
 750         db._db.deleteInfohash(fake_infoahsh)
 751         db._db.deleteInfohash(fake_infoahsh2)
 752         tid = db._db.getTorrentID(fake_infoahsh)
 753         assert tid is None
 754         tid = db._db.getTorrentID(fake_infoahsh2)
 755         assert tid is None
 756         assert oldinfohash_size == db._db.size('Torrent'), [oldinfohash_size, db._db.size('Torrent')]
 757
 758 ###--------------------------------------------------------------------------------------------------------------------------
 759 class TestPopularityDBHandler(unittest.TestCase):
 760
 761     def setUp(self):
 762         db_path = TRIBLER_DB_PATH
 763         db = SQLiteCacheDB.getInstance()
 764         db.openDB(db_path, busytimeout=BUSYTIMEOUT)
 765
 766     def tearDown(self):
 767         SQLiteCacheDB.getInstance().close()
 768
 769     def singtest_addPopularity(self):
 770         print "Testing addPopularity module...\n"
 771         pop_db = PopularityDBHandler.getInstance()
 772
 773 #torrent_id, peer_id, recv_time, calc_age=sys.maxint, num_seeders=-1, num_leechers=-1, num_sources=-1
 774         oldpop_size = pop_db.size()
 775         pop_db.addPopularity(2,1,1241787491,78,25,456,5)
 776         pop_db.addPopularity(2,1,1241787490,7028,2,45,15)
 777         pop_db.addPopularity(50000,1,1241787495,78,25,4546456,5)
 778         assert pop_db.size() == oldpop_size + 3
 779 ###--------------------------------------------------------------------------------------------------------------------------
 780
 781     def singtest_storePeerPopularity(self):
 782         print "Testing storePeerPopularity module...\n"
 783
 784         pop_db = PopularityDBHandler.getInstance()
 785         oldpop_size = pop_db.size()
 786         #(torrent_id, recv_time, calc_age, num_seeders, num_leechers, num_sources)
 787         tList=[(10,123456,1000,5,18,8),
 788                (11,123457,1001,52,28,5),
 789                (12,123458,1002,53,38,8),
 790                (12,123459,1003,55,58,9),
 791                (12,123451,1004,57,68,12),
 792                (12,1234,100,57,68,12)]
 793         tList=[]
 794         pop_db.storePeerPopularity(100, tList)
 795
 796         pop_db.addPopularity(12,1,895,78,25,4546456,5)
 797         pop_db.addPopularity(12,18,300000,78,25,4546456,5)
 798         pop_db.addPopularity(12,1,1895,8,25,4546456,5)
 799         pop_db.addPopularity(13,18,200,8978,25,4546456,5)
 800         pop_db.addPopularity(50000,1,85554544,78,25,4546456,5)
 801
 802         #assert pop_db.size() == oldpop_size + 5
 803
 804 ###--------------------------------------------------------------------------------------------------------------------------
 805     def singtest_countTorrentPopularityRec(self):
 806         print "Testing countTorrentPopularity module...\n"
 807
 808         pop_db = PopularityDBHandler.getInstance()
 809
 810         tList=[(10,123456,1000,5,18,8),
 811                (10,123457,1001,52,28,5),
 812                (12,123458,2002,53,38,8),
 813                (12,123459,1003,55,58,9),
 814                (12,123451,4004,57,68,12),
 815                (17,123451,1004,57,68,12),
 816                (19,123451,1004,57,68,12)]
 817
 818         pop_db.storePeerPopularity(100, tList)
 819
 820         result = pop_db.countTorrentPopularityRec(10, int(time()))
 821         print "(num_records, oldest_record) = ( %d, %d)" % (result[0], result[1])
 822
 823 ###--------------------------------------------------------------------------------------------------------------------------
 824     def singtest_countTorrentPeerPopularityRec(self):
 825         print "Testing countTorrentPeerPopularity module...\n"
 826
 827         pop_db = PopularityDBHandler.getInstance()
 828
 829         tList=[(10,123456,1000,5,18,8),
 830                (10,123457,1001,52,28,5),
 831                (12,123458,1002,53,38,8),
 832                (12,123459,6003,55,58,9),
 833                (12,123451,3004,57,68,12),
 834                (17,123451,1004,57,68,12),
 835                (19,123451,1004,57,68,12)]
 836
 837         pop_db.storePeerPopularity(100, tList)
 838         result = pop_db.countTorrentPeerPopularityRec(12, 100, int(time()))
 839         print "(num_records, oldest_record) = ( %d, %d)" % (result[0], result[1])
 840
 841         pop_db.addPopularity(2,1,85554544,78,25,4546456,5)
 842         pop_db.addPopularity(1,1,855545442,78,25,4546456,5)
 843         pop_db.addPopularity(1,1,85554523,78,25,4546456,5)
 844         pop_db.addPopularity(50000,1,85554544,78,25,4546456,5)
 845         result = pop_db.countTorrentPeerPopularityRec(1, 1, int(time()))
 846         print "(num_records, oldest_record) = ( %d, %d)" % (result[0], result[1])
 847
 848 ###--------------------------------------------------------------------------------------------------------------------------
 849     def singtest_deleteOldTorrentRecords(self):
 850         print "Testing deleteOldTorrentRecords module...\n"
 851
 852         pop_db = PopularityDBHandler.getInstance()
 853
 854         tList=[(10,123456,1000,5,18,8),
 855                (10,123457,1001,52,28,5),
 856                (12,123458,1002,53,38,8),
 857                (12,123459,1003,55,58,9),
 858                (12,123451,1004,57,68,12),
 859                (17,123451,1004,57,68,12),
 860                (19,123451,1004,57,68,12)]
 861         pop_db.storePeerPopularity(100, tList)
 862
 863         pop_db.addPopularity(2,1,85554544,78,25,4546456,5)
 864         pop_db.addPopularity(1,1,855545442,788,25,4546456,5)
 865         pop_db.addPopularity(1,1,85554523,78,25,4546456,5)
 866         pop_db.addPopularity(50000,1,85554544,78,25,4546456,5)
 867
 868         result = pop_db.countTorrentPopularityRec(1, int(time()))
 869         print "Before delete: (num_records, oldest_record) = ( %d, %d)" % (result[0], result[1])
 870
 871         pop_db.deleteOldTorrentRecords(1,1,int(time()))
 872
 873         result = pop_db.countTorrentPopularityRec(1, int(time()))
 874         print "After delete: (num_records, oldest_record) = ( %d, %d)" % (result[0], result[1])
 875
 876 ###--------------------------------------------------------------------------------------------------------------------------
 877     def singtest_deleteOldTorrentPeerRecords(self):
 878         print "Testing deleteOldTorrentRecords module...\n"
 879
 880         pop_db = PopularityDBHandler.getInstance()
 881
 882         tList=[(10,123456,1000,5,18,8),
 883                (10,123457,1001,52,28,5),
 884                (12,123458,1002,53,38,8),
 885                (12,123459,1003,55,58,9),
 886                (12,123451,1004,57,68,12),
 887                (17,123451,1004,57,68,12),
 888                (19,123451,1004,57,68,12)]
 889         pop_db.storePeerPopularity(100, tList)
 890
 891         pop_db.addPopularity(12,1,85554544,78,25,4546456,5)
 892         pop_db.addPopularity(12,13,855545442,78,25,4546456,5)
 893         pop_db.addPopularity(1,1,85554523,78,25,4546456,5)
 894         pop_db.addPopularity(50000,1,85554544,78,25,4546456,5)
 895
 896         result = pop_db.countTorrentPeerPopularityRec(12,100, int(time()))
 897         print "Before delete: (num_records, oldest_record) = ( %d, %d)" % (result[0], result[1])
 898
 899         pop_db.deleteOldTorrentPeerRecords(12,100,4, int(time()))
 900
 901         result = pop_db.countTorrentPeerPopularityRec(12,100, int(time()))
 902         print "After delete: (num_records, oldest_record) = ( %d, %d)" % (result[0], result[1])
 903
 904 ##--------------------------------------------------------------------------------------------------------------------------
 905     def singtest_getPopularityList(self):
 906         print "Testing getPopularityList module...\n"
 907
 908         pop_db = PopularityDBHandler.getInstance()
 909
 910         tList=[(10,123456,1000,5,18,8),
 911                (10,123457,1001,52,28,5),
 912                (12,123458,1002,53,38,8),
 913                (12,123459,1003,55,58,9),
 914                (12,1619999,1004,57,68,12),
 915                (17,123460,1004,57,68,12),
 916                (19,123451,1004,57,68,12)]
 917
 918         pop_db.storePeerPopularity(100, tList)
 919         pop_db.addPopularity(12,1,1194958935,78,25,2194958935,5)
 920         pop_db.addPopularity(12,13,855545442,78,25,4546456,5)
 921         pop_db.addPopularity(1,1,85554523,78,25,4546456,5)
 922         pop_db.addPopularity(50000,1,85554544,78,25,4546456,5)
 923
 924         print pop_db.getPopularityList(peer_id=100)
 925         print pop_db.getPopularityList(peer_id=100, torrent_id=12)
 926         print pop_db.getPopularityList(torrent_id=12)
 927         print pop_db.getPopularityList(recv_time_lbound=123457)
 928         print pop_db.getPopularityList(peer_id=100, torrent_id=12, recv_time_ubound=123458,recv_time_lbound=123457)
 929         print pop_db.getPopularityList()
 930
 931     def singtest_calculateSwarmSize(self):
 932         print "Testing calculate swarm size module...\n"
 933         pop_db = PopularityDBHandler.getInstance()
 934         self.singtest_getPopularityList()
 935         #tempList =[2726, 2059, 899999, 42918, 4269, 4065]
 936         tempList =[12,17, 4847, 4816, 4783, 2627]
 937         print "swarm size:\n"
 938         print pop_db.calculateSwarmSize(tempList, "TorrentIds")
 939
 940 ##--------------------------------------------------------------------------------------------------------------------------
 941 class TestTorrentDBHandler(unittest.TestCase):
 942
 943     def setUp(self):
 944         db_path = TRIBLER_DB_PATH
 945         db = SQLiteCacheDB.getInstance()
 946         db.openDB(db_path, busytimeout=BUSYTIMEOUT)
 947
 948     def tearDown(self):
 949         SQLiteCacheDB.getInstance().close()
 950
 951     def singtested_functions(self):
 952         if SHOW_NOT_TESTED_FUNCTIONS:
 953             all_funcs = getFuncs2Test(TorrentDBHandler)
 954             tested_funcs = [
 955                 "register",
 956                 "getInstance",
 957                 "hasTorrent",
 958                 "hasMetaData",
 959                 "getNumberTorrents", "_getCategoryID",
 960                 "getTorrents",
 961                 "size",
 962                 "getTorrentID",
 963                 "_addTorrentToDB", "_addTorrentTracker",
 964                 "getOne",
 965                 "getTracker",
 966                 "updateTorrent",
 967                 "updateTorrentRelevance",
 968                 "deleteTorrent", "_deleteTorrent", "eraseTorrentFile",
 969                 "getNumberCollectedTorrents",
 970                 "getTorrent",
 971                 "freeSpace",
 972                 "getInfohash",
 973             ]
 974             for func in all_funcs:
 975                 if func not in tested_funcs:
 976                     print "TestTorrentDBHandler: not test", func
 977
 978 #    def singtest_misc(self):
 979 #        db = TorrentDBHandler.getInstance()
 980
 981     def _test_hasTorrent(self):
 982         infohash_str = 'AA8cTG7ZuPsyblbRE7CyxsrKUCg='
 983         infohash = str2bin(infohash_str)
 984         db = TorrentDBHandler.getInstance()
 985         assert db.hasTorrent(infohash) == True
 986         assert db.hasMetaData(infohash) == True
 987         fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00\x07*\x86H\xce=\x02'
 988         assert db.hasTorrent(fake_infoahsh) == False
 989         assert db.hasMetaData(fake_infoahsh) == False
 990
 991     def singtest_count(self):
 992         db = TorrentDBHandler.getInstance()
 993         start = time()
 994         num = db.getNumberTorrents()
 995         assert num == 4483
 996
 997     def singtest_loadTorrents(self):
 998         db = TorrentDBHandler.getInstance()
 999         torrent_size = db._db.size('CollectedTorrent')
1000         db2 = MyPreferenceDBHandler.getInstance()
1001         mypref_size = db2.size()
1002         res = db.getTorrents()
1003         ### assert len(res) == torrent_size - mypref_size, (len(res), torrent_size - mypref_size)
1004         res = db.getTorrents()
1005         len(res) == torrent_size
1006         data = res[0]
1007         #print data
1008         assert data['category'][0] in db.category_table.keys(), data['category']
1009         assert data['status'] in db.status_table.keys(), data['status']
1010         assert data['source'] in db.src_table.keys(), data['source']
1011         assert len(data['infohash']) == 20
1012
1013     def singtest_add_update_delete_Torrent(self):
1014         self.addTorrent()
1015         self.updateTorrent()
1016         self.deleteTorrent()
1017
1018     def addTorrent(self):
1019         copyFile(S_TORRENT_PATH_BACKUP, S_TORRENT_PATH)
1020         copyFile(M_TORRENT_PATH_BACKUP, M_TORRENT_PATH)
1021
1022         db = TorrentDBHandler.getInstance()
1023
1024         old_size = db.size()
1025         old_src_size = db._db.size('TorrentSource')
1026         old_tracker_size = db._db.size('TorrentTracker')
1027
1028         s_infohash = unhexlify('44865489ac16e2f34ea0cd3043cfd970cc24ec09')
1029         m_infohash = unhexlify('ed81da94d21ad1b305133f2726cdaec5a57fed98')
1030
1031         sid = db._db.getTorrentID(s_infohash)
1032         mid = db._db.getTorrentID(m_infohash)
1033
1034         single_torrent_file_path = os.path.join(FILES_DIR, 'single.torrent')
1035         multiple_torrent_file_path = os.path.join(FILES_DIR, 'multiple.torrent')
1036
1037         single_tdef = TorrentDef.load(single_torrent_file_path)
1038         assert s_infohash == single_tdef.get_infohash()
1039         src = 'http://www.rss.com/torrent.xml'
1040         multiple_tdef = TorrentDef.load(multiple_torrent_file_path)
1041         assert m_infohash == multiple_tdef.get_infohash()
1042
1043         db.addExternalTorrent(single_tdef, extra_info={'filename':single_torrent_file_path})
1044         db.addExternalTorrent(multiple_tdef, source=src, extra_info={'filename':multiple_torrent_file_path})
1045
1046         single_torrent_id = db._db.getTorrentID(s_infohash)
1047         multiple_torrent_id = db._db.getTorrentID(m_infohash)
1048
1049         assert db.getInfohash(single_torrent_id) == s_infohash
1050
1051         single_name = 'Tribler_4.1.7_src.zip'
1052         multiple_name = 'Tribler_4.1.7_src'
1053
1054         assert db.size() == old_size + 2, old_size - db.size()
1055         assert old_src_size + 1 == db._db.size('TorrentSource')
1056         assert old_tracker_size + 2 == db._db.size('TorrentTracker'), db._db.size('TorrentTracker')-old_tracker_size
1057
1058         sname = db.getOne('name', torrent_id=single_torrent_id)
1059         assert sname == single_name, (sname,single_name)
1060         mname = db.getOne('name', torrent_id=multiple_torrent_id)
1061         assert mname == multiple_name, (mname,multiple_name)
1062
1063         s_size = db.getOne('length', torrent_id=single_torrent_id)
1064         assert s_size == 1583233, s_size
1065         m_size = db.getOne('length', torrent_id=multiple_torrent_id)
1066         assert m_size == 5358560, m_size
1067
1068         cat = db.getOne('category_id', torrent_id=multiple_torrent_id)
1069         assert cat == 8, cat    # other
1070         sid = db._db.getOne('TorrentSource', 'source_id', name=src)
1071         assert sid > 1
1072         m_sid = db.getOne('source_id', torrent_id=multiple_torrent_id)
1073         assert sid == m_sid
1074         s_sid = db.getOne('source_id', torrent_id=single_torrent_id)
1075         assert 1 == s_sid
1076         s_status = db.getOne('status_id', torrent_id=single_torrent_id)
1077         assert s_status == 0
1078
1079         m_comment = db.getOne('comment', torrent_id=multiple_torrent_id)
1080         comments = 'www.tribler.org'
1081         assert m_comment.find(comments)>-1
1082         comments = 'something not inside'
1083         assert m_comment.find(comments)==-1
1084
1085         m_trackers = db.getTracker(m_infohash, 0)    #db._db.getAll('TorrentTracker', 'tracker', 'torrent_id=%d'%multiple_torrent_id)
1086         assert len(m_trackers) == 1
1087         assert ('http://tpb.tracker.thepiratebay.org/announce',1) in m_trackers, m_trackers
1088
1089         s_torrent = db.getTorrent(s_infohash)
1090         m_torrent = db.getTorrent(m_infohash)
1091         assert s_torrent['name'] == 'Tribler_4.1.7_src.zip', s_torrent['name']
1092         assert m_torrent['name'] == 'Tribler_4.1.7_src', m_torrent['name']
1093         assert m_torrent['last_check_time'] == 0
1094         assert len(s_torrent) == 16
1095         assert len(m_torrent) == 16
1096
1097     def updateTorrent(self):
1098         db = TorrentDBHandler.getInstance()
1099
1100         s_infohash = unhexlify('44865489ac16e2f34ea0cd3043cfd970cc24ec09')
1101         m_infohash = unhexlify('ed81da94d21ad1b305133f2726cdaec5a57fed98')
1102         kw = {}
1103         db.updateTorrent(m_infohash, relevance=3.1415926, category=['Videoclips'],
1104                          status='good', progress=23.5, seeder=123, leecher=321,
1105                          last_check_time=1234567, ignore_number=1, retry_number=2,
1106                          other_key1='abcd', other_key2=123)
1107         multiple_torrent_id = db._db.getTorrentID(m_infohash)
1108         res_r = db.getOne('relevance', torrent_id=multiple_torrent_id)
1109         ### assert 3.1415926 == res_r
1110         db.updateTorrentRelevance(m_infohash, 1.41421)
1111         res_r = db.getOne('relevance', torrent_id=multiple_torrent_id)
1112         ### assert 1.41421 == res_r
1113         cid = db.getOne('category_id', torrent_id=multiple_torrent_id)
1114         ### assert cid == 2, cid
1115         sid = db.getOne('status_id', torrent_id=multiple_torrent_id)
1116         assert sid == 1
1117         p = db.mypref_db.getOne('progress', torrent_id=multiple_torrent_id)
1118         assert p == None, p
1119         seeder = db.getOne('num_seeders', torrent_id=multiple_torrent_id)
1120         assert seeder == 123
1121         leecher = db.getOne('num_leechers', torrent_id=multiple_torrent_id)
1122         assert leecher == 321
1123         last_check_time = db._db.getOne('TorrentTracker', 'last_check', announce_tier=1, torrent_id=multiple_torrent_id)
1124         assert last_check_time == 1234567, last_check_time
1125         ignore_number = db._db.getOne('TorrentTracker', 'ignored_times', announce_tier=1, torrent_id=multiple_torrent_id)
1126         assert ignore_number == 1
1127         retry_number = db._db.getOne('TorrentTracker', 'retried_times', announce_tier=1, torrent_id=multiple_torrent_id)
1128         assert retry_number == 2
1129
1130     def deleteTorrent(self):
1131         db = TorrentDBHandler.getInstance()
1132         db.torrent_dir = FILES_DIR
1133         s_infohash = unhexlify('44865489ac16e2f34ea0cd3043cfd970cc24ec09')
1134         m_infohash = unhexlify('ed81da94d21ad1b305133f2726cdaec5a57fed98')
1135
1136         assert db.deleteTorrent(s_infohash, delete_file=True)
1137         assert db.deleteTorrent(m_infohash)
1138
1139         assert not db.hasTorrent(s_infohash)
1140         assert not db.hasTorrent(m_infohash)
1141         assert not os.path.isfile(S_TORRENT_PATH)
1142         m_trackers = db.getTracker(m_infohash, 0)
1143         assert len(m_trackers) == 0
1144
1145         # fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00\x07*\x86H\xce=\x02'
1146         # 02/02/10 Boudewijn: infohashes must be 20 bytes long
1147         fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00'
1148         assert not db.deleteTorrent(fake_infoahsh)
1149
1150         my_infohash_str_126 = 'ByJho7yj9mWY1ORWgCZykLbU1Xc='
1151         my_infohash = str2bin(my_infohash_str_126)
1152         assert not db.deleteTorrent(my_infohash)
1153
1154     def singtest_getCollectedTorrentHashes(self):
1155         db = TorrentDBHandler.getInstance()
1156         res = db.getNumberCollectedTorrents()
1157         assert res == 4848, res
1158
1159     def singtest_freeSpace(self):
1160         db = TorrentDBHandler.getInstance()
1161         old_res = db.getNumberCollectedTorrents()
1162         db.freeSpace(20)
1163         res = db.getNumberCollectedTorrents()
1164         assert old_res - res == 20
1165         init()
1166
1167
1168 class TestMyPreferenceDBHandler(unittest.TestCase):
1169
1170     def setUp(self):
1171         db_path = TRIBLER_DB_PATH
1172         db = SQLiteCacheDB.getInstance()
1173         db.openDB(db_path, busytimeout=BUSYTIMEOUT)
1174         mypref_db = MyPreferenceDBHandler.getInstance()
1175         mypref_db.loadData()
1176
1177     def tearDown(self):
1178         SQLiteCacheDB.getInstance().close()
1179
1180     def singtest_getPrefList(self):
1181         db = MyPreferenceDBHandler.getInstance()
1182         pl = db.getMyPrefListInfohash()
1183         assert len(pl) == 12
1184
1185     def singtest_getCreationTime(self):
1186         db = MyPreferenceDBHandler.getInstance()
1187         infohash_str_126 = 'ByJho7yj9mWY1ORWgCZykLbU1Xc='
1188         infohash = str2bin(infohash_str_126)
1189         ct = db.getCreationTime(infohash)
1190         assert ct == 1194966300, ct
1191
1192     def singtest_getRecentLivePrefList(self):
1193         db = MyPreferenceDBHandler.getInstance()
1194         pl = db.getRecentLivePrefList()
1195         assert len(pl) == 11, (len(pl), pl)
1196         infohash_str_126 = 'ByJho7yj9mWY1ORWgCZykLbU1Xc='
1197         assert bin2str(pl[0]) == infohash_str_126
1198         infohash_str_1279 = 'R+grUhp884MnFkt6NuLnnauZFsc='
1199         assert bin2str(pl[1]) == infohash_str_1279
1200
1201         pl = db.getRecentLivePrefList(8)
1202         assert len(pl) == 8, (len(pl), pl)
1203         assert bin2str(pl[0]) == infohash_str_126
1204         assert bin2str(pl[1]) == infohash_str_1279
1205
1206     def singtest_hasMyPreference(self):
1207         infohash_str_126 = 'ByJho7yj9mWY1ORWgCZykLbU1Xc='
1208         infohash_str_1279 = 'R+grUhp884MnFkt6NuLnnauZFsc='
1209         db = MyPreferenceDBHandler.getInstance()
1210         assert db.hasMyPreference(str2bin(infohash_str_126))
1211         assert db.hasMyPreference(str2bin(infohash_str_1279))
1212         # fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00\x07*\x86H\xce=\x02'
1213         # 02/02/10 Boudewijn: infohashes must be 20 bytes long
1214         fake_infoahsh = 'fake_infohash_1'+'0R0\x10\x00'
1215         assert not db.hasMyPreference(fake_infoahsh)
1216
1217     def singtest_addMyPreference_deletePreference(self):
1218         db = MyPreferenceDBHandler.getInstance()
1219         p = db.getOne(('torrent_id', 'destination_path', 'progress', 'creation_time'), torrent_id=126)
1220         torrent_id = p[0]
1221         infohash = db._db.getInfohash(torrent_id)
1222         destpath = p[1]
1223         progress = p[2]
1224         creation_time = p[3]
1225         db.deletePreference(infohash)
1226         pl = db.getMyPrefListInfohash()
1227         assert len(pl) == 11
1228         assert infohash not in pl
1229
1230         data = {'destination_path':destpath}
1231         db.addMyPreference(infohash, data)
1232         p2 = db.getOne(('torrent_id', 'destination_path', 'progress', 'creation_time'), torrent_id=126)
1233         assert p2[0] == p[0] and p2[1] == p[1] and p2[2] == 0 and time()-p2[3] < 10 , p2
1234
1235         db.deletePreference(infohash)
1236         pl = db.getMyPrefListInfohash()
1237         assert len(pl) == 11
1238         assert infohash not in pl
1239
1240         data = {'destination_path':destpath, 'progress':progress, 'creation_time':creation_time}
1241         db.addMyPreference(infohash, data)
1242         p3 = db.getOne(('torrent_id', 'destination_path', 'progress', 'creation_time'), torrent_id=126)
1243         assert p3 == p, p3
1244
1245     def singtest_updateProgress(self):
1246         infohash_str_126 = 'ByJho7yj9mWY1ORWgCZykLbU1Xc='
1247         infohash = str2bin(infohash_str_126)
1248         db = MyPreferenceDBHandler.getInstance()
1249         assert db.hasMyPreference(infohash)
1250         torrent_id = db._db.getTorrentID(infohash)
1251         db.updateProgress(infohash, 3.14)
1252         p = db.getOne('progress', torrent_id=torrent_id)
1253         assert p == 3.14
1254
1255     def singtest_getMyPrefListInfohash(self):
1256         db = MyPreferenceDBHandler.getInstance()
1257         preflist = db.getMyPrefListInfohash()
1258         for p in preflist:
1259             assert len(p) == 20
1260         assert len(preflist) == 12
1261
1262     def singtest_getMyPrefStats(self):
1263         db = MyPreferenceDBHandler.getInstance()
1264         res = db.getMyPrefStats()
1265         assert len(res)==12
1266         for k in res:
1267             data = res[k]
1268             assert len(data) == 3
1269
1270 def test_suite():
1271     suite = unittest.TestSuite()
1272     # We should run the tests in a separate Python interpreter to prevent
1273     # problems with our singleton classes, e.g. PeerDB, etc.
1274     if len(sys.argv) != 3:
1275         print "Usage: python test_so.py <class name> <method name>"
1276     else:
1277         for class_ in unittest.TestCase.__subclasses__():
1278             if class_.__name__ == sys.argv[1]:
1279                 init()
1280                 suite.addTest(class_(sys.argv[2]))
1281     return suite
1282
1283 def main():
1284     unittest.main(defaultTest='test_suite',argv=[sys.argv[0]])
1285
1286 if __name__ == "__main__":
1287     main()
1288
1289