ppf/new/tests/test_parsing.py

   1 """
   2 Test suite for parsing.py. Uses unittest module.
   3
   4 2011, Razvan Deaconescu, razvan.deaconescu@cs.pub.ro
   5 """
   6
   7 import unittest
   8 import os
   9 import os.path
  10 import shutil
  11 import sys
  12
  13 import parsing
  14 import storage
  15
  16 class LibtorrentLogParserTest(unittest.TestCase):
  17     """Test suite for LibtorrentLogParser class in parsing.py."""
  18
  19     ok_dir = "ok_dir"
  20     no_dir = "no_dir"
  21     status_file = "status.log"
  22     verbose_file1 = "141.85.224.201_12345.log"
  23     verbose_file2 = "141.85.224.202_12345.log"
  24     verbose_file3 = "141.85.224.203_12345.log"
  25     bogus_file1 = "dht.log"
  26     bogus_file2 = "141.85.224.203.log"
  27     bogus_file3 = "12345.log"
  28
  29     def setUp(self):
  30         # Create folder and log files.
  31         os.mkdir(self.ok_dir)
  32         self.ok_status_file_path = os.path.join(self.ok_dir,
  33                 self.status_file)
  34         self.ok_verbose_file_path1 = os.path.join(self.ok_dir,
  35                 self.verbose_file1)
  36         self.ok_verbose_file_path2 = os.path.join(self.ok_dir,
  37                 self.verbose_file2)
  38         self.ok_verbose_file_path3 = os.path.join(self.ok_dir,
  39                 self.verbose_file3)
  40         self.ok_bogus_file_path1 = os.path.join(self.ok_dir,
  41                 self.bogus_file1)
  42         self.ok_bogus_file_path2 = os.path.join(self.ok_dir,
  43                 self.bogus_file2)
  44         self.ok_bogus_file_path3 = os.path.join(self.ok_dir,
  45                 self.bogus_file3)
  46         f = open(self.ok_status_file_path, "w")
  47         f.close()
  48         f = open(self.ok_verbose_file_path1, "w")
  49         f.close()
  50         f = open(self.ok_verbose_file_path2, "w")
  51         f.close()
  52         f = open(self.ok_verbose_file_path3, "w")
  53         f.close()
  54         f = open(self.ok_bogus_file_path1, "w")
  55         f.close()
  56         f = open(self.ok_bogus_file_path2, "w")
  57         f.close()
  58         f = open(self.ok_bogus_file_path3, "w")
  59         f.close()
  60
  61         # Initialize message type counters.
  62         self.statmsg_cnt = 0
  63         self.pstatmsg_cnt = 0
  64         self.verbmsg_cnt = 0
  65
  66         # Initialize internal call counts.
  67         self.bogus_line_num_calls = 0
  68         self.status_line_num_calls = 0
  69         self.peer_status_line_num_calls = 0
  70         self.verbose_line_num_calls = 0
  71
  72         # Remove no_dir in case it exists.
  73         try:
  74             shutil.rmtree(self.no_dir)
  75         except OSError, e:
  76             pass
  77
  78     def tearDown(self):
  79         shutil.rmtree(self.ok_dir)
  80         # Remove no_dir in case it exists.
  81         try:
  82             shutil.rmtree(self.no_dir)
  83         except OSError, e:
  84             pass
  85
  86     def append_line(self, filename, line):
  87         """Add (append) a line to to a file."""
  88         f = open(filename, "at")
  89         f.write(line + "\n")
  90         f.close()
  91
  92     def add_bogus_line(self, filename):
  93         """Add bogus (non-relevant) line to file."""
  94         if self.bogus_line_num_calls == 0:
  95             self.append_line(filename, "Nebuchadnezzar")
  96         else:
  97             self.append_line(filename, "Assurbanipal")
  98         self.bogus_line_num_calls = self.bogus_line_num_calls + 1
  99
 100     def add_status_line(self, filename):
 101         """Add status line to file."""
 102         if self.status_line_num_calls == 0:
 103             self.append_line(filename, "ps: 5, dht: 21 <> dl: 462.1kb/s, ul: 255.2kb/s <> dld: 45mb, uld: 3mb, size: 698mb <> eta: 24m 7s")
 104         else:
 105             self.append_line(filename, "ps: 5, dht: 21 <> dl: 469kb/s, ul: 255.66kb/s <> dld: 46mb, uld: 4mb, size: 698mb <> eta: 23m 45s")
 106         self.status_line_num_calls = self.status_line_num_calls + 1
 107
 108     def add_peer_status_line(self, filename):
 109         """Add peer status line to file."""
 110         if self.peer_status_line_num_calls == 0:
 111             self.append_line(filename, "--Peers: (Aug 14 17:22:35) [ ip: 10.1.7.5:33289, dl: 86.63kb/s, ul: 175.07kb/s ][ ip: 10.1.9.5:55611, dl: 14.63kb/s, ul: 110.79kb/s ][ ip: 10.1.8.5:6881, dl: 2.96kb/s, ul: 92.85kb/s ][ ip: 10.1.6.5:47254, dl: 80.1kb/s, ul: 176.44kb/s ][ ip: 10.1.4.5:6881, dl: 115.16kb/s, ul: 167.83kb/s ][ ip: 10.1.5.5:45222, dl: 108.39kb/s, ul: 158.11kb/s ][ ip: 10.1.10.5:48923, dl: 66.16kb/s, ul: 121.92kb/s ][ ip: 10.1.1.5:51146, dl: 198.66kb/s, ul: 6.11kb/s ]")
 112         else:
 113             self.append_line(filename, "--Peers: (Aug 14 17:22:40) [ ip: 10.1.7.5:33289, dl: 23.6kb/s, ul: 94.91kb/s ][ ip: 10.1.6.5:47254, dl: 55.61kb/s, ul: 100.72kb/s ][ ip: 10.1.4.5:6881, dl: 93.99kb/s, ul: 100.11kb/s ][ ip: 10.1.10.5:48923, dl: 57.42kb/s, ul: 205.74kb/s ]")
 114         self.peer_status_line_num_calls = self.peer_status_line_num_calls + 1
 115
 116     def add_verbose_line(self, filename):
 117         """Add verbose line to file."""
 118         if self.verbose_line_num_calls == 0:
 119             self.append_line(filename, "Jan 08 22:20:50 <== REQUEST [ piece: 8a | s: 38000 | l: 4000 ]")
 120         else:
 121             self.append_line(filename, "Jan 08 22:20:50 ==> PIECE   [ piece: 8a | s: 34000 | l: 4000 ]")
 122         self.verbose_line_num_calls = self.verbose_line_num_calls + 1
 123
 124     def add_message_to_count(self, msg):
 125         """Update message type counters according to msg."""
 126         if msg.__class__ == storage.StatusMessage:
 127             self.statmsg_count = self.statmsg_count + 1
 128         elif msg.__class__ == storage.StatusMessage:
 129             self.statmsg_count = self.statmsg_count + 1
 130         elif msg.__class__ == storage.StatusMessage:
 131             self.statmsg_count = self.statmsg_count + 1
 132
 133     def test_non_existent_folder(self):
 134         """libtorrent log folder doesn't exist.
 135         Exception should be raised.
 136         """
 137         exception_raised = False
 138         try:
 139             p = parsing.LibtorrentLogParser(self.no_dir)
 140         except OSError, e:
 141             exception_raised = True
 142
 143         self.assertEqual(exception_raised, True)
 144
 145     def test_no_log_files(self):
 146         """No log files are present in the log folder.
 147         Exception should be raised.
 148         """
 149         # Remove files.
 150         os.remove(self.ok_status_file_path)
 151         os.remove(self.ok_verbose_file_path1)
 152         os.remove(self.ok_verbose_file_path2)
 153         os.remove(self.ok_verbose_file_path3)
 154
 155         exception_raised = False
 156         try:
 157             p = parsing.LibtorrentLogParser(self.ok_dir)
 158         except (IOError, OSError, IndexError), e:
 159             exception_raised = True
 160
 161         self.assertEqual(exception_raised, True)
 162
 163     def test_get_parsing_file_no_status_log_file(self):
 164         """No status log file is present.
 165         Use get_current_parsing_filename() to get current log file.
 166         """
 167         # Remove status log file.
 168         os.remove(self.ok_status_file_path)
 169
 170         p = parsing.LibtorrentLogParser(self.ok_dir)
 171         current = p.get_current_parsing_filename()
 172
 173         value = (current == self.ok_verbose_file_path1 or
 174                 current == self.ok_verbose_file_path2 or
 175                 current == self.ok_verbose_file_path3)
 176         self.assertEqual(value, True)
 177
 178     def test_get_to_parse_files_no_status_log_files(self):
 179         """No status log file is present.
 180         Use get_to_parse_list() to get files to be parsed.
 181         """
 182         # Remove status log file.
 183         os.remove(self.ok_status_file_path)
 184
 185         # to_parse list should consists of 2 entries: the verbose log
 186         # files minus the one that is currently being parsed.
 187         p = parsing.LibtorrentLogParser(self.ok_dir)
 188         count = len(p.get_to_parse_list())
 189
 190         self.assertEqual(count, 2)
 191
 192     def test_get_parsing_file_no_verbose_log_files(self):
 193         """No verbose log file is present.
 194         Use get_current_parsing_filename() to get current log file.
 195         """
 196         # Remove status log file.
 197         os.remove(self.ok_verbose_file_path1)
 198         os.remove(self.ok_verbose_file_path2)
 199         os.remove(self.ok_verbose_file_path3)
 200
 201         p = parsing.LibtorrentLogParser(self.ok_dir)
 202         current = p.get_current_parsing_filename()
 203
 204         value = (current == self.ok_status_file_path)
 205         self.assertEqual(value, True)
 206
 207     def test_get_to_parse_files_no_verbose_log_files(self):
 208         """No verbose log file is present.
 209         Use get_to_parse_list() to get files to be parsed.
 210         """
 211         # Remove verbose log files.
 212         os.remove(self.ok_verbose_file_path1)
 213         os.remove(self.ok_verbose_file_path2)
 214         os.remove(self.ok_verbose_file_path3)
 215
 216         # to_parse list should be empty: no verbose files and the
 217         # status file is currently being parsed.
 218         p = parsing.LibtorrentLogParser(self.ok_dir)
 219         count = len(p.get_to_parse_list())
 220
 221         self.assertEqual(count, 0)
 222
 223     def test_get_parsing_status_priority(self):
 224         """Set priority as "status".
 225         get_current_parsing_filename() should return status log file.
 226         """
 227         p = parsing.LibtorrentLogParser(self.ok_dir, priority="status")
 228         current = p.get_current_parsing_filename()
 229
 230         value = (current == self.ok_status_file_path)
 231         self.assertEqual(value, True)
 232
 233     def test_get_parsing_verbose_priority(self):
 234         """Set priority as "status".
 235         get_current_parsing_filename() should return a verbose log file.
 236         """
 237         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 238         current = p.get_current_parsing_filename()
 239
 240         value = (current == self.ok_verbose_file_path1 or
 241                 current == self.ok_verbose_file_path2 or
 242                 current == self.ok_verbose_file_path3)
 243         self.assertEqual(value, True)
 244
 245     def test_get_message_no_status_log_file_empty_verbose_log_files(self):
 246         """Status log file does not exist, verbose log files are empty.
 247         Returned message should be None.
 248         """
 249         # Remove status log file.
 250         os.remove(self.ok_status_file_path)
 251
 252         p = parsing.LibtorrentLogParser(self.ok_dir)
 253         msg = p.get_next_message()
 254
 255         self.assertEqual(msg, None)
 256
 257     def test_get_message_no_verbose_log_files_empty_status_log_file(self):
 258         """Verbose log files do not exist, status log file is empty.
 259         Returned message should be None.
 260         """
 261         # Remove verbose log files.
 262         os.remove(self.ok_verbose_file_path1)
 263         os.remove(self.ok_verbose_file_path2)
 264         os.remove(self.ok_verbose_file_path3)
 265
 266         p = parsing.LibtorrentLogParser(self.ok_dir)
 267         msg = p.get_next_message()
 268
 269         self.assertEqual(msg, None)
 270
 271     def test_get_message_empty_log_files(self):
 272         """Log files are empty.
 273         Returned message should be None.
 274         """
 275         p = parsing.LibtorrentLogParser(self.ok_dir)
 276         msg = p.get_next_message()
 277
 278         self.assertEqual(msg, None)
 279
 280     def test_get_none_message_in_status_log_file(self):
 281         """Status log file consists of bogus information (no messages).
 282         Set priority as "status".
 283         Message is returned from verbose log file.
 284         """
 285         self.add_bogus_line(self.ok_status_file_path)
 286         self.add_verbose_line(self.ok_verbose_file_path1)
 287
 288         p = parsing.LibtorrentLogParser(self.ok_dir, priority="status")
 289         msg = p.get_next_message()
 290
 291         self.add_message_to_count(msg)
 292
 293         self.assertEqual(self.statmsg_cnt, 1)
 294
 295     def test_get_none_message_in_verbose_log_files(self):
 296         """Verbose log files consist of bogus information (no messages).
 297         Set priority as "verbose".
 298         Message is returned from status log file.
 299         """
 300         self.add_bogus_line(self.ok_verbose_file_path1)
 301         self.add_bogus_line(self.ok_verbose_file_path2)
 302         self.add_bogus_line(self.ok_verbose_file_path3)
 303         self.add_status_line(self.ok_status_file_path)
 304
 305         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 306         msg = p.get_next_message()
 307
 308         self.add_message_to_count(msg)
 309
 310         self.assertEqual(self.verbmsg_cnt, 1)
 311
 312     def test_get_status_message(self):
 313         """Return a status message from status log file."""
 314         self.add_status_line(self.ok_status_file_path)
 315
 316         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 317         msg = p.get_next_message()
 318
 319         self.add_message_to_count(msg)
 320
 321         self.assertEqual(self.statmsg_cnt, 1)
 322
 323     def test_get_status_messages(self):
 324         """Return multiple status messages from status log file."""
 325         self.add_status_line(self.ok_status_file_path)
 326         self.add_status_line(self.ok_status_file_path)
 327
 328         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 329         msg1 = p.get_next_message()
 330         msg2 = p.get_next_message()
 331
 332         self.add_message_to_count(msg1)
 333         self.add_message_to_count(msg2)
 334
 335         self.assertEqual(self.statmsg_cnt, 2)
 336
 337     def test_get_status_messages_different_files(self):
 338         """Return multiple status messages from different log files."""
 339         self.add_status_line(self.ok_status_file_path)
 340         self.add_status_line(self.ok_verbose_file_path1)
 341
 342         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 343         msg1 = p.get_next_message()
 344         msg2 = p.get_next_message()
 345
 346         self.add_message_to_count(msg1)
 347         self.add_message_to_count(msg2)
 348
 349         self.assertEqual(self.statmsg_cnt, 2)
 350
 351     def test_get_peer_status_message(self):
 352         """Return a peer status message from status log file."""
 353         self.add_peer_status_line(self.ok_status_file_path)
 354
 355         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 356         msg = p.get_next_message()
 357
 358         self.add_message_to_count(msg)
 359
 360         self.assertEqual(self.pstatmsg_cnt, 1)
 361
 362     def test_get_peer_status_messages(self):
 363         """Return multiple peer status messages from status log file."""
 364         self.add_peer_status_line(self.ok_status_file_path)
 365         self.add_peer_status_line(self.ok_status_file_path)
 366
 367         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 368         msg1 = p.get_next_message()
 369         msg2 = p.get_next_message()
 370
 371         self.add_message_to_count(msg1)
 372         self.add_message_to_count(msg2)
 373
 374         self.assertEqual(self.pstatmsg_cnt, 2)
 375
 376     def test_get_peer_status_messages_different_files(self):
 377         """Return multiple peer status messages from different log files."""
 378         self.add_peer_status_line(self.ok_status_file_path)
 379         self.add_peer_status_line(self.ok_verbose_file_path1)
 380
 381         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 382         msg1 = p.get_next_message()
 383         msg2 = p.get_next_message()
 384
 385         self.add_message_to_count(msg1)
 386         self.add_message_to_count(msg2)
 387
 388         self.assertEqual(self.pstatmsg_cnt, 2)
 389
 390     def test_get_verbose_message(self):
 391         """Return a verbose message from verbose log file."""
 392         self.add_verbose_line(self.ok_verbose_file_path1)
 393
 394         p = parsing.LibtorrentLogParser(self.ok_dir, priority="status")
 395         msg = p.get_next_message()
 396
 397         self.add_message_to_count(msg)
 398
 399         self.assertEqual(self.verbmsg_cnt, 1)
 400
 401     def test_get_verbose_messages(self):
 402         """Return multiple verbose messages from verbose log file."""
 403         self.add_verbose_line(self.ok_verbose_file_path1)
 404         self.add_verbose_line(self.ok_verbose_file_path1)
 405
 406         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 407         msg1 = p.get_next_message()
 408         msg2 = p.get_next_message()
 409
 410         self.add_message_to_count(msg1)
 411         self.add_message_to_count(msg2)
 412
 413         self.assertEqual(self.verbmsg_cnt, 2)
 414
 415     def test_get_verbose_messages_different_files(self):
 416         """Return multiple verbose messages from different log files."""
 417         self.add_verbose_line(self.ok_verbose_file_path1)
 418         self.add_verbose_line(self.ok_verbose_file_path2)
 419
 420         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 421         msg1 = p.get_next_message()
 422         msg2 = p.get_next_message()
 423
 424         self.add_message_to_count(msg1)
 425         self.add_message_to_count(msg2)
 426
 427         self.assertEqual(self.verbmsg_cnt, 2)
 428
 429     def test_get_mixed_messages_same_file(self):
 430         """Status file contains multiple messages of different types."""
 431         self.add_status_line(self.ok_status_file_path)
 432         self.add_peer_status_line(self.ok_status_file_path)
 433         self.add_verbose_line(self.ok_status_file_path)
 434
 435         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 436         msg1 = p.get_next_message()
 437         msg2 = p.get_next_message()
 438         msg3 = p.get_next_message()
 439
 440         self.add_message_to_count(msg1)
 441         self.add_message_to_count(msg2)
 442         self.add_message_to_count(msg3)
 443
 444         value = (self.statmsg_cnt == 1 and self.pstatmsg_cnt == 1 and \
 445                 self.verbmsg_cnt == 1)
 446         self.assertEqual(value, True)
 447
 448     def test_get_mixed_messages_own_file(self):
 449         """Each log file contains a single type of messages."""
 450         self.add_status_line(self.ok_status_file_path)
 451         self.add_status_line(self.ok_status_file_path)
 452         self.add_peer_status_line(self.ok_verbose_file_path1)
 453         self.add_peer_status_line(self.ok_verbose_file_path1)
 454         self.add_verbose_line(self.ok_verbose_file_path2)
 455         self.add_verbose_line(self.ok_verbose_file_path2)
 456
 457         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 458         msg1 = p.get_next_message()
 459         msg2 = p.get_next_message()
 460         msg3 = p.get_next_message()
 461         msg4 = p.get_next_message()
 462         msg5 = p.get_next_message()
 463         msg6 = p.get_next_message()
 464
 465         self.add_message_to_count(msg1)
 466         self.add_message_to_count(msg2)
 467         self.add_message_to_count(msg3)
 468         self.add_message_to_count(msg4)
 469         self.add_message_to_count(msg5)
 470         self.add_message_to_count(msg6)
 471
 472         value = (self.statmsg_cnt == 2 and self.pstatmsg_cnt == 2 and \
 473                 self.verbmsg_cnt == 2)
 474         self.assertEqual(value, True)
 475
 476     def test_get_mixed_messages_different_files(self):
 477         """Log files contain different message types."""
 478         self.add_status_line(self.ok_status_file_path)
 479         self.add_status_line(self.ok_status_file_path)
 480         self.add_peer_status_line(self.ok_verbose_file_path1)
 481         self.add_peer_status_line(self.ok_verbose_file_path1)
 482         self.add_verbose_line(self.ok_verbose_file_path2)
 483         self.add_verbose_line(self.ok_verbose_file_path2)
 484
 485         p = parsing.LibtorrentLogParser(self.ok_dir, priority="verbose")
 486         msg1 = p.get_next_message()
 487         msg2 = p.get_next_message()
 488         msg3 = p.get_next_message()
 489         msg4 = p.get_next_message()
 490         msg5 = p.get_next_message()
 491         msg6 = p.get_next_message()
 492
 493         self.add_message_to_count(msg1)
 494         self.add_message_to_count(msg2)
 495         self.add_message_to_count(msg3)
 496         self.add_message_to_count(msg4)
 497         self.add_message_to_count(msg5)
 498         self.add_message_to_count(msg6)
 499
 500         value = (self.statmsg_cnt == 2 and self.pstatmsg_cnt == 2 and \
 501                 self.verbmsg_cnt == 2)
 502         self.assertEqual(value, True)
 503
 504
 505 class TriblerLogParserTest(unittest.TestCase):
 506     """Test suite for TriblerLogParser class in parsing.py."""
 507
 508     def setUp(self):
 509         pass
 510
 511     def tearDown(self):
 512         pass
 513
 514
 515 if __name__ == "__main__":
 516     unittest.main()