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_count = 0
  63         self.pstatmsg_count = 0
  64         self.verbmsg_count = 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 ]")
 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 ]")
 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.PeerStatusMessage:
 129             self.pstatmsg_count = self.pstatmsg_count + 1
 130         elif msg.__class__ == storage.VerboseMessage:
 131             self.verbmsg_count = self.verbmsg_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                     "2009-01-01 12:13:14")
 141         except OSError, e:
 142             exception_raised = True
 143
 144         self.assertEqual(exception_raised, True)
 145
 146     def test_no_log_files(self):
 147         """No log files are present in the log folder.
 148         Exception should be raised.
 149         """
 150         # Remove files.
 151         os.remove(self.ok_status_file_path)
 152         os.remove(self.ok_verbose_file_path1)
 153         os.remove(self.ok_verbose_file_path2)
 154         os.remove(self.ok_verbose_file_path3)
 155
 156         exception_raised = False
 157         try:
 158             p = parsing.LibtorrentLogParser(self.ok_dir,
 159                     "2009-01-01 12:13:14")
 160         except (IOError, OSError, IndexError), e:
 161             exception_raised = True
 162
 163         self.assertEqual(exception_raised, True)
 164
 165     def test_get_parsing_file_no_status_log_file(self):
 166         """No status log file is present.
 167         Use get_current_parsing_filename() to get current log file.
 168         """
 169         # Remove status log file.
 170         os.remove(self.ok_status_file_path)
 171
 172         p = parsing.LibtorrentLogParser(self.ok_dir, "2009-01-01 12:13:14")
 173         current = p.get_current_parsing_filename()
 174
 175         value = (current == self.ok_verbose_file_path1 or
 176                 current == self.ok_verbose_file_path2 or
 177                 current == self.ok_verbose_file_path3)
 178         self.assertEqual(value, True)
 179
 180     def test_get_to_parse_files_no_status_log_files(self):
 181         """No status log file is present.
 182         Use get_to_parse_list() to get files to be parsed.
 183         """
 184         # Remove status log file.
 185         os.remove(self.ok_status_file_path)
 186
 187         # to_parse list should consists of 2 entries: the verbose log
 188         # files minus the one that is currently being parsed.
 189         p = parsing.LibtorrentLogParser(self.ok_dir, "2009-01-01 12:13:14")
 190         count = len(p.get_to_parse_list())
 191
 192         self.assertEqual(count, 2)
 193
 194     def test_get_parsing_file_no_verbose_log_files(self):
 195         """No verbose log file is present.
 196         Use get_current_parsing_filename() to get current log file.
 197         """
 198         # Remove status log file.
 199         os.remove(self.ok_verbose_file_path1)
 200         os.remove(self.ok_verbose_file_path2)
 201         os.remove(self.ok_verbose_file_path3)
 202
 203         p = parsing.LibtorrentLogParser(self.ok_dir, "2009-01-01 12:13:14")
 204         current = p.get_current_parsing_filename()
 205
 206         value = (current == self.ok_status_file_path)
 207         self.assertEqual(value, True)
 208
 209     def test_get_to_parse_files_no_verbose_log_files(self):
 210         """No verbose log file is present.
 211         Use get_to_parse_list() to get files to be parsed.
 212         """
 213         # Remove verbose log files.
 214         os.remove(self.ok_verbose_file_path1)
 215         os.remove(self.ok_verbose_file_path2)
 216         os.remove(self.ok_verbose_file_path3)
 217
 218         # to_parse list should be empty: no verbose files and the
 219         # status file is currently being parsed.
 220         p = parsing.LibtorrentLogParser(self.ok_dir, "2009-01-01 12:13:14")
 221         count = len(p.get_to_parse_list())
 222
 223         self.assertEqual(count, 0)
 224
 225     def test_get_parsing_status_priority(self):
 226         """Set priority as "status".
 227         get_current_parsing_filename() should return status log file.
 228         """
 229         p = parsing.LibtorrentLogParser(self.ok_dir,
 230                 "2009-01-01 12:13:14", priority="status")
 231         current = p.get_current_parsing_filename()
 232
 233         value = (current == self.ok_status_file_path)
 234         self.assertEqual(value, True)
 235
 236     def test_get_parsing_verbose_priority(self):
 237         """Set priority as "status".
 238         get_current_parsing_filename() should return a verbose log file.
 239         """
 240         p = parsing.LibtorrentLogParser(self.ok_dir,
 241                 "2009-01-01 12:13:14", priority="verbose")
 242         current = p.get_current_parsing_filename()
 243
 244         value = (current == self.ok_verbose_file_path1 or
 245                 current == self.ok_verbose_file_path2 or
 246                 current == self.ok_verbose_file_path3)
 247         self.assertEqual(value, True)
 248
 249     def test_get_message_no_status_log_file_empty_verbose_log_files(self):
 250         """Status log file does not exist, verbose log files are empty.
 251         Returned message should be None.
 252         """
 253         # Remove status log file.
 254         os.remove(self.ok_status_file_path)
 255
 256         p = parsing.LibtorrentLogParser(self.ok_dir, "2009-01-01 12:13:14")
 257         msg = p.get_next_message()
 258
 259         self.assertEqual(msg, None)
 260
 261     def test_get_message_no_verbose_log_files_empty_status_log_file(self):
 262         """Verbose log files do not exist, status log file is empty.
 263         Returned message should be None.
 264         """
 265         # Remove verbose log files.
 266         os.remove(self.ok_verbose_file_path1)
 267         os.remove(self.ok_verbose_file_path2)
 268         os.remove(self.ok_verbose_file_path3)
 269
 270         p = parsing.LibtorrentLogParser(self.ok_dir, "2009-01-01 12:13:14")
 271         msg = p.get_next_message()
 272
 273         self.assertEqual(msg, None)
 274
 275     def test_get_message_empty_log_files(self):
 276         """Log files are empty.
 277         Returned message should be None.
 278         """
 279         p = parsing.LibtorrentLogParser(self.ok_dir, "2009-01-01 12:13:14")
 280         msg = p.get_next_message()
 281
 282         self.assertEqual(msg, None)
 283
 284     def test_get_none_message_in_status_log_file(self):
 285         """Status log file consists of bogus information (no messages).
 286         Set priority as "status".
 287         Message is returned from verbose log file.
 288         """
 289         self.add_bogus_line(self.ok_status_file_path)
 290         self.add_verbose_line(self.ok_verbose_file_path1)
 291
 292         p = parsing.LibtorrentLogParser(self.ok_dir,
 293                 "2009-01-01 12:13:14", priority="status")
 294         msg = p.get_next_message()
 295
 296         self.add_message_to_count(msg)
 297
 298         self.assertEqual(self.verbmsg_count, 1)
 299
 300     def test_get_none_message_in_verbose_log_files(self):
 301         """Verbose log files consist of bogus information (no messages).
 302         Set priority as "verbose".
 303         Message is returned from status log file.
 304         """
 305         self.add_bogus_line(self.ok_verbose_file_path1)
 306         self.add_bogus_line(self.ok_verbose_file_path2)
 307         self.add_bogus_line(self.ok_verbose_file_path3)
 308         self.add_status_line(self.ok_status_file_path)
 309
 310         p = parsing.LibtorrentLogParser(self.ok_dir,
 311                 "2009-01-01 12:13:14", priority="verbose")
 312         msg = p.get_next_message()
 313
 314         self.add_message_to_count(msg)
 315
 316         self.assertEqual(self.statmsg_count, 1)
 317
 318     def test_get_status_message(self):
 319         """Return a status message from status log file."""
 320         self.add_status_line(self.ok_status_file_path)
 321
 322         p = parsing.LibtorrentLogParser(self.ok_dir,
 323                 "2009-01-01 12:13:14", priority="verbose")
 324         msg = p.get_next_message()
 325
 326         self.add_message_to_count(msg)
 327
 328         self.assertEqual(self.statmsg_count, 1)
 329
 330     def test_get_status_messages(self):
 331         """Return multiple status messages from status log file."""
 332         self.add_status_line(self.ok_status_file_path)
 333         self.add_status_line(self.ok_status_file_path)
 334
 335         p = parsing.LibtorrentLogParser(self.ok_dir,
 336                 "2009-01-01 12:13:14", priority="verbose")
 337         msg1 = p.get_next_message()
 338         msg2 = p.get_next_message()
 339
 340         self.add_message_to_count(msg1)
 341         self.add_message_to_count(msg2)
 342
 343         self.assertEqual(self.statmsg_count, 2)
 344
 345     def test_get_status_messages_different_files(self):
 346         """Return multiple status messages from different log files."""
 347         self.add_status_line(self.ok_status_file_path)
 348         self.add_status_line(self.ok_verbose_file_path1)
 349
 350         p = parsing.LibtorrentLogParser(self.ok_dir,
 351                 "2009-01-01 12:13:14", priority="verbose")
 352         msg1 = p.get_next_message()
 353         msg2 = p.get_next_message()
 354
 355         self.add_message_to_count(msg1)
 356         self.add_message_to_count(msg2)
 357
 358         self.assertEqual(self.statmsg_count, 2)
 359
 360     def test_get_peer_status_message(self):
 361         """Return a peer status message from status log file."""
 362         self.add_peer_status_line(self.ok_status_file_path)
 363
 364         p = parsing.LibtorrentLogParser(self.ok_dir,
 365                 "2009-01-01 12:13:14", priority="verbose")
 366         msg = p.get_next_message()
 367
 368         self.add_message_to_count(msg)
 369
 370         self.assertEqual(self.pstatmsg_count, 1)
 371
 372     def test_get_peer_status_messages(self):
 373         """Return multiple peer status messages from status log file."""
 374         self.add_peer_status_line(self.ok_status_file_path)
 375         self.add_peer_status_line(self.ok_status_file_path)
 376
 377         p = parsing.LibtorrentLogParser(self.ok_dir,
 378                 "2009-01-01 12:13:14", priority="verbose")
 379         msg1 = p.get_next_message()
 380         msg2 = p.get_next_message()
 381         msg3 = p.get_next_message()
 382         msg4 = p.get_next_message()
 383         msg5 = p.get_next_message()
 384
 385         self.add_message_to_count(msg1)
 386         self.add_message_to_count(msg2)
 387         self.add_message_to_count(msg3)
 388         self.add_message_to_count(msg4)
 389         self.add_message_to_count(msg5)
 390
 391         self.assertEqual(self.pstatmsg_count, 5)
 392
 393     def test_get_peer_status_messages_different_files(self):
 394         """Return multiple peer status messages from different log files."""
 395         self.add_peer_status_line(self.ok_status_file_path)
 396         self.add_peer_status_line(self.ok_verbose_file_path1)
 397
 398         p = parsing.LibtorrentLogParser(self.ok_dir,
 399                 "2009-01-01 12:13:14", priority="verbose")
 400         msg1 = p.get_next_message()
 401         msg2 = p.get_next_message()
 402         msg3 = p.get_next_message()
 403         msg4 = p.get_next_message()
 404         msg5 = p.get_next_message()
 405
 406         self.add_message_to_count(msg1)
 407         self.add_message_to_count(msg2)
 408         self.add_message_to_count(msg3)
 409         self.add_message_to_count(msg4)
 410         self.add_message_to_count(msg5)
 411
 412         self.assertEqual(self.pstatmsg_count, 5)
 413
 414     def test_get_verbose_message(self):
 415         """Return a verbose message from verbose log file."""
 416         self.add_verbose_line(self.ok_verbose_file_path1)
 417
 418         p = parsing.LibtorrentLogParser(self.ok_dir,
 419                 "2009-01-01 12:13:14", priority="status")
 420         msg = p.get_next_message()
 421
 422         self.add_message_to_count(msg)
 423
 424         self.assertEqual(self.verbmsg_count, 1)
 425
 426     def test_get_verbose_messages(self):
 427         """Return multiple verbose messages from verbose log file."""
 428         self.add_verbose_line(self.ok_verbose_file_path1)
 429         self.add_verbose_line(self.ok_verbose_file_path1)
 430
 431         p = parsing.LibtorrentLogParser(self.ok_dir,
 432                 "2009-01-01 12:13:14", priority="verbose")
 433         msg1 = p.get_next_message()
 434         msg2 = p.get_next_message()
 435
 436         self.add_message_to_count(msg1)
 437         self.add_message_to_count(msg2)
 438
 439         self.assertEqual(self.verbmsg_count, 2)
 440
 441     def test_get_verbose_messages_different_files(self):
 442         """Return multiple verbose messages from different log files."""
 443         self.add_verbose_line(self.ok_verbose_file_path1)
 444         self.add_verbose_line(self.ok_verbose_file_path2)
 445
 446         p = parsing.LibtorrentLogParser(self.ok_dir,
 447                 "2009-01-01 12:13:14", priority="verbose")
 448         msg1 = p.get_next_message()
 449         msg2 = p.get_next_message()
 450
 451         self.add_message_to_count(msg1)
 452         self.add_message_to_count(msg2)
 453
 454         self.assertEqual(self.verbmsg_count, 2)
 455
 456     def test_get_mixed_messages_same_file(self):
 457         """Status file contains multiple messages of different types."""
 458         self.add_status_line(self.ok_status_file_path)
 459         self.add_peer_status_line(self.ok_status_file_path)
 460         self.add_verbose_line(self.ok_status_file_path)
 461
 462         p = parsing.LibtorrentLogParser(self.ok_dir,
 463                 "2009-01-01 12:13:14", priority="verbose")
 464         msg1 = p.get_next_message()
 465         msg2 = p.get_next_message()
 466         msg3 = p.get_next_message()
 467         msg4 = p.get_next_message()
 468
 469         self.add_message_to_count(msg1)
 470         self.add_message_to_count(msg2)
 471         self.add_message_to_count(msg3)
 472         self.add_message_to_count(msg4)
 473
 474         self.assertEqual(self.statmsg_count, 1)
 475         self.assertEqual(self.pstatmsg_count, 2)
 476         self.assertEqual(self.verbmsg_count, 1)
 477
 478     def test_get_mixed_messages_own_file(self):
 479         """Each log file contains a single type of messages."""
 480         self.add_status_line(self.ok_status_file_path)
 481         self.add_status_line(self.ok_status_file_path)
 482         self.add_peer_status_line(self.ok_verbose_file_path1)
 483         self.add_peer_status_line(self.ok_verbose_file_path1)
 484         self.add_verbose_line(self.ok_verbose_file_path2)
 485         self.add_verbose_line(self.ok_verbose_file_path2)
 486
 487         p = parsing.LibtorrentLogParser(self.ok_dir,
 488                 "2009-01-01 12:13:14", priority="verbose")
 489         msg1 = p.get_next_message()
 490         msg2 = p.get_next_message()
 491         msg3 = p.get_next_message()
 492         msg4 = p.get_next_message()
 493         msg5 = p.get_next_message()
 494         msg6 = p.get_next_message()
 495         msg7 = p.get_next_message()
 496         msg8 = p.get_next_message()
 497         msg9 = p.get_next_message()
 498
 499         self.add_message_to_count(msg1)
 500         self.add_message_to_count(msg2)
 501         self.add_message_to_count(msg3)
 502         self.add_message_to_count(msg4)
 503         self.add_message_to_count(msg5)
 504         self.add_message_to_count(msg6)
 505         self.add_message_to_count(msg7)
 506         self.add_message_to_count(msg8)
 507         self.add_message_to_count(msg9)
 508
 509         self.assertEqual(self.statmsg_count, 2)
 510         self.assertEqual(self.pstatmsg_count, 5)
 511         self.assertEqual(self.verbmsg_count, 2)
 512
 513     def test_get_mixed_messages_different_files(self):
 514         """Log files contain different message types."""
 515         self.add_status_line(self.ok_status_file_path)
 516         self.add_status_line(self.ok_status_file_path)
 517         self.add_peer_status_line(self.ok_verbose_file_path1)
 518         self.add_peer_status_line(self.ok_verbose_file_path1)
 519         self.add_verbose_line(self.ok_verbose_file_path2)
 520         self.add_verbose_line(self.ok_verbose_file_path2)
 521
 522         p = parsing.LibtorrentLogParser(self.ok_dir,
 523                 "2009-01-01 12:13:14", priority="verbose")
 524         msg1 = p.get_next_message()
 525         msg2 = p.get_next_message()
 526         msg3 = p.get_next_message()
 527         msg4 = p.get_next_message()
 528         msg5 = p.get_next_message()
 529         msg6 = p.get_next_message()
 530         msg7 = p.get_next_message()
 531         msg8 = p.get_next_message()
 532         msg9 = p.get_next_message()
 533
 534         self.add_message_to_count(msg1)
 535         self.add_message_to_count(msg2)
 536         self.add_message_to_count(msg3)
 537         self.add_message_to_count(msg4)
 538         self.add_message_to_count(msg5)
 539         self.add_message_to_count(msg6)
 540         self.add_message_to_count(msg7)
 541         self.add_message_to_count(msg8)
 542         self.add_message_to_count(msg9)
 543
 544         self.assertEqual(self.statmsg_count, 2)
 545         self.assertEqual(self.pstatmsg_count, 5)
 546         self.assertEqual(self.verbmsg_count, 2)
 547
 548
 549 class TriblerLogParserTest(unittest.TestCase):
 550     """Test suite for TriblerLogParser class in parsing.py."""
 551
 552     log_file = 'tribler.log'
 553     no_log_file = 'no.log'
 554
 555     def setUp(self):
 556         """Create log file and initiate local counter variables."""
 557         f = open(self.log_file, "w")
 558         f.close()
 559
 560         # Initialize message type counters.
 561         self.statmsg_count = 0
 562         self.pstatmsg_count = 0
 563         self.verbmsg_count = 0
 564
 565         # Initialize internal call counts.
 566         self.bogus_line_num_calls = 0
 567         self.status_line_num_calls = 0
 568         self.peer_status_line_num_calls = 0
 569         self.verbose_line_num_calls = 0
 570
 571         # Remove no log file in case it exists.
 572         try:
 573             os.remove(self.no_log_file)
 574         except OSError, e:
 575             pass
 576
 577     def tearDown(self):
 578         """Remove log file."""
 579         os.remove(self.log_file)
 580
 581     def append_line(self, filename, line):
 582         """Add (append) a line to to a file."""
 583         f = open(filename, "at")
 584         f.write(line + "\n")
 585         f.close()
 586
 587     def add_bogus_line(self, filename):
 588         """Add bogus (non-relevant) line to file."""
 589         if self.bogus_line_num_calls == 0:
 590             self.append_line(filename, "Nebuchadnezzar")
 591         else:
 592             self.append_line(filename, "Assurbanipal")
 593         self.bogus_line_num_calls = self.bogus_line_num_calls + 1
 594
 595     def add_status_line(self, filename):
 596         """Add status line to file."""
 597         if self.status_line_num_calls == 0:
 598             pass
 599         else:
 600             pass
 601         self.status_line_num_calls = self.status_line_num_calls + 1
 602
 603     def add_peer_status_line(self, filename):
 604         """Add peer status line to file."""
 605         if self.peer_status_line_num_calls == 0:
 606             pass
 607         else:
 608             pass
 609         self.peer_status_line_num_calls = self.peer_status_line_num_calls + 1
 610
 611     def add_verbose_line(self, filename):
 612         """Add verbose line to file."""
 613         if self.verbose_line_num_calls == 0:
 614             pass
 615         else:
 616             pass
 617         self.verbose_line_num_calls = self.verbose_line_num_calls + 1
 618
 619     def add_message_to_count(self, msg):
 620         """Update message type counters according to msg."""
 621         if msg.__class__ == storage.StatusMessage:
 622             self.statmsg_count = self.statmsg_count + 1
 623         elif msg.__class__ == storage.PeerStatusMessage:
 624             self.pstatmsg_count = self.pstatmsg_count + 1
 625         elif msg.__class__ == storage.VerboseMessage:
 626             self.verbmsg_count = self.verbmsg_count + 1
 627
 628     def test_no_log_file(self):
 629         """Log file doesn't exist."""
 630         exception_raised = False
 631         try:
 632             p = parsing.TriblerLogParser(self.no_log_file,
 633                     "2009-01-01 12:13:14")
 634         except (IOError, OSError, IndexError), e:
 635             exception_raised = True
 636
 637         self.assertEqual(exception_raised, True)
 638
 639     def test_empty_log_file(self):
 640         """Log file is empty."""
 641         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 642
 643         msg = p.get_next_message()
 644
 645         self.assertEqual(msg, None)
 646
 647     def test_bogus_log_file(self):
 648         """Log file contains bogus information (no real data)."""
 649         self.add_bogus_line(self.log_file)
 650         self.add_bogus_line(self.log_file)
 651         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 652
 653         msg = p.get_next_message()
 654
 655         self.assertEqual(msg, None)
 656
 657     def test_get_status_message(self):
 658         """Add status message."""
 659         self.add_status_line(self.log_file)
 660         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 661
 662         msg = p.get_next_message()
 663         self.add_message_to_count(msg)
 664
 665         self.assertEqual(self.statmsg_count, 1)
 666
 667     def test_get_status_messages(self):
 668         """Add multiple status messages."""
 669         self.add_status_line(self.log_file)
 670         self.add_status_line(self.log_file)
 671         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 672
 673         msg1 = p.get_next_message()
 674         msg2 = p.get_next_message()
 675         self.add_message_to_count(msg1)
 676         self.add_message_to_count(msg2)
 677
 678         self.assertEqual(self.statmsg_count, 2)
 679
 680     def test_get_peer_status_message(self):
 681         """Add peer status message."""
 682         self.add_peer_status_line(self.log_file)
 683         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 684
 685         msg = p.get_next_message()
 686         self.add_message_to_count(msg)
 687
 688         self.assertEqual(self.pstatmsg_count, 1)
 689
 690     def test_get_peer_status_messages(self):
 691         """Add multiple peer status messsages."""
 692         self.add_peer_status_line(self.log_file)
 693         self.add_peer_status_line(self.log_file)
 694         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 695
 696         msg1 = p.get_next_message()
 697         msg2 = p.get_next_message()
 698         self.add_message_to_count(msg1)
 699         self.add_message_to_count(msg2)
 700
 701         self.assertEqual(self.pstatmsg_count, 2)
 702
 703     def test_get_verbose_message(self):
 704         """Add verbose message."""
 705         self.add_verbose_line(self.log_file)
 706         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 707
 708         msg = p.get_next_message()
 709         self.add_message_to_count(msg)
 710
 711         self.assertEqual(self.verbmsg_count, 1)
 712
 713     def test_get_verbose_messages(self):
 714         """Add multiple verbose messages."""
 715         self.add_verbose_line(self.log_file)
 716         self.add_verbose_line(self.log_file)
 717         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 718
 719         msg1 = p.get_next_message()
 720         msg2 = p.get_next_message()
 721         self.add_message_to_count(msg1)
 722         self.add_message_to_count(msg2)
 723
 724         self.assertEqual(self.verbmsg_count, 2)
 725
 726     def test_get_mixed_messages_same_file(self):
 727         """Add mixed messages in the same file.
 728         Parser should detect a message of each type (status, peer status
 729         and verbose).
 730         """
 731         self.add_bogus_line(self.log_file)
 732         self.add_status_line(self.log_file)
 733         self.add_peer_status_line(self.log_file)
 734         self.add_verbose_line(self.log_file)
 735         p = parsing.TriblerLogParser(self.log_file, "2009-01-01 12:13:14")
 736
 737         msg1 = p.get_next_message()
 738         msg2 = p.get_next_message()
 739         msg3 = p.get_next_message()
 740         self.add_message_to_count(msg1)
 741         self.add_message_to_count(msg2)
 742         self.add_message_to_count(msg3)
 743
 744         self.assertEqual(self.statmsg_count, 1)
 745         self.assertEqual(self.pstatmsg_count, 1)
 746         self.assertEqual(self.verbmsg_count, 1)
 747
 748
 749 if __name__ == "__main__":
 750 #    suite = unittest.TestSuite()
 751 #    suite.addTest(LibtorrentLogParserTest('test_get_status_message'))
 752 #    suite.addTest(LibtorrentLogParserTest('test_get_status_messages'))
 753 #    suite.addTest(LibtorrentLogParserTest('test_get_status_messages_different_files'))
 754 #    suite.addTest(LibtorrentLogParserTest('test_get_verbose_message'))
 755 #    suite.addTest(LibtorrentLogParserTest('test_get_verbose_messages'))
 756 #    suite.addTest(LibtorrentLogParserTest('test_get_verbose_messages_different_files'))
 757 #    suite.addTest(LibtorrentLogParserTest('test_get_mixed_messages_same_file'))
 758 #    unittest.TextTestRunner().run(suite)
 759     unittest.main()