def test_cmd_queue_peaks(self): """Check that the queue peaks command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/queue.log', ) peaks = log_file.cmd_queue_peaks() self.assertEqual(len(peaks), 4) self.assertEqual(peaks[0]['peak'], 4) self.assertEqual(peaks[0]['span'], 5) self.assertEqual(peaks[1]['peak'], 19) self.assertEqual(peaks[1]['span'], 5) self.assertEqual(peaks[2]['peak'], 49) self.assertEqual(peaks[2]['span'], 3) self.assertEqual(peaks[3]['peak'], 3) self.assertEqual(peaks[3]['span'], 1) self.assertTrue(peaks[0]['first'] < peaks[1]['first']) self.assertTrue(peaks[1]['first'] < peaks[2]['first']) self.assertTrue(peaks[2]['first'] < peaks[3]['first']) self.assertTrue(peaks[0]['last'] < peaks[1]['last']) self.assertTrue(peaks[1]['last'] < peaks[2]['last']) self.assertTrue(peaks[2]['last'] < peaks[3]['last'])
def test_cmd_average_response_time(self): """Check that the average response time returns the expected output.""" log_file = Log( logfile='haproxy/tests/files/average_response.log', ) data = log_file.cmd_average_response_time() self.assertEqual(data, 105)
def test_cmd_requests_per_minute(self): """Check that the requests per minute command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/requests_per_minute.log', ) requests = log_file.cmd_requests_per_minute() self.assertEqual(len(requests), 5) self.assertEqual( requests[0], (datetime(2013, 12, 11, 11, 2), 8) ) self.assertEqual( requests[1], (datetime(2013, 12, 11, 11, 3), 3) ) self.assertEqual( requests[2], (datetime(2013, 12, 11, 11, 13), 5) ) self.assertEqual( requests[3], (datetime(2013, 12, 11, 11, 52), 7) ) self.assertEqual( requests[4], (datetime(2013, 12, 11, 12, 2), 9) )
def test_cmd_requests_per_minute_empty(self): """Check that the requests per minute command reports nothing if there are no valid lines for whichever reason. """ log_file = Log(logfile='haproxy/tests/files/empty.log', ) requests = log_file.cmd_requests_per_minute() self.assertEqual(None, requests)
def test_cmd_average_waiting_time_aborted(self): """Check that the average time waiting on queues returns the expected output when there are aborted connections. """ log_file = Log( logfile='haproxy/tests/files/average_waiting_aborted.log', ) data = log_file.cmd_average_waiting_time() self.assertEqual(data, 110)
def test_cmd_average_response_time_no_wait(self): """Check that the average response time returns the expected output when there are connections that did not take any millisecond to reply. """ log_file = Log( logfile='haproxy/tests/files/average_response_no_wait.log', ) data = log_file.cmd_average_response_time() self.assertEqual(data, 74)
def test_cmd_print(self): """Check that the print command prints the valid lines.""" log_file = Log(logfile='haproxy/tests/files/2_ok_1_invalid.log', ) data = log_file.cmd_print() self.assertNotEqual('', data) lines = data.split('\n') self.assertEqual(len(lines), 3)
def test_cmd_slow_requests(self): """Check that the slow requests command reports as expected.""" log_file = Log(logfile='haproxy/tests/files/small.log') slow_requests = log_file.cmd_slow_requests() self.assertEqual(len(slow_requests), 5) slow_requests.sort() # sort them as the log analyzer sorts by dates self.assertEqual(slow_requests, [1293, 2936, 2942, 20095, 29408])
def test_cmd_average_waiting_time(self): """Check that the average time waiting on queues returns the expected output. """ log_file = Log( logfile='haproxy/tests/files/average_waiting.log', ) data = log_file.cmd_average_waiting_time() self.assertEqual(data, 105)
def test_cmd_average_waiting_time_empty_log(self): """Check that the average time waiting on queues does not break if no log lines are logged. """ log_file = Log( logfile='haproxy/tests/files/empty.log', ) data = log_file.cmd_average_waiting_time() self.assertEqual(data, 0)
def test_valid_and_invalid_lines(self): """Check that if some log lines can not be parsed both numbers are correctly reported. """ log_file = Log( logfile='haproxy/tests/files/2_ok_1_invalid.log' ) self.assertEqual(log_file.cmd_counter(), 2) self.assertEqual(log_file.cmd_counter_invalid(), 1)
def test_cmd_counter_slow_requests(self): """Check that the slow requests counter command reports as expected. """ log_file = Log( logfile='haproxy/tests/files/small.log', ) slow_requests = log_file.cmd_counter_slow_requests() self.assertEqual(slow_requests, 5)
def test_cmd_status_codes(self): """Check that the status codes command reports as expected.""" log_file = Log(logfile='haproxy/tests/files/small.log') status_codes = log_file.cmd_status_codes_counter() self.assertEqual(len(status_codes), 3) self.assertEqual(status_codes['404'], 3) self.assertEqual(status_codes['200'], 2) self.assertEqual(status_codes['300'], 4)
def test_cmd_server_load(self): """Check that the server load counter command reports as expected.""" log_file = Log(logfile='haproxy/tests/files/small.log') servers = log_file.cmd_server_load() self.assertEqual(len(servers), 3) self.assertEqual(servers['instance1'], 4) self.assertEqual(servers['instance2'], 3) self.assertEqual(servers['instance3'], 2)
def test_cmd_connection_type(self): """Check that the connection type command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/connection.log', ) ssl, non_ssl = log_file.cmd_connection_type() self.assertEqual(ssl, 7) self.assertEqual(non_ssl, 5)
def test_cmd_http_methods(self): """Check that the http methods command reports as expected.""" log_file = Log(logfile='haproxy/tests/files/small.log') http_methods = log_file.cmd_http_methods() self.assertEqual(len(http_methods), 3) self.assertEqual(http_methods['GET'], 4) self.assertEqual(http_methods['POST'], 2) self.assertEqual(http_methods['HEAD'], 3)
def test_cmd_average_waiting_time_no_wait(self): """Check that the average time waiting on queues returns the expected output when there are requests that did not wait at all (i.e. time_wait_queues is 0). """ log_file = Log( logfile='haproxy/tests/files/average_waiting_no_wait.log') data = log_file.cmd_average_waiting_time() self.assertEqual(data, 52.5)
def test_cmd_print_empty(self): """Check that the print command prints an empty string if the log file is empty. """ log_file = Log( logfile='haproxy/tests/files/empty.log', ) data = log_file.cmd_print() self.assertEqual('', data)
def test_cmd_ip_counter(self): """Check that the ip counter command reports as expected.""" log_file = Log(logfile='haproxy/tests/files/small.log', ) ip_counter = log_file.cmd_ip_counter() self.assertEqual(len(ip_counter), 4) self.assertEqual(ip_counter['123.123.123.123'], 4) self.assertEqual(ip_counter['123.123.124.124'], 2) self.assertEqual(ip_counter['123.123.124.123'], 1) self.assertEqual(ip_counter['123.123.123.124'], 1)
def test_cmd_requests_per_minute_empty(self): """Check that the requests per minute command reports nothing if there are no valid lines for whichever reason. """ log_file = Log( logfile='haproxy/tests/files/empty.log', ) requests = log_file.cmd_requests_per_minute() self.assertEqual(None, requests)
def test_cmd_print(self): """Check that the print command prints the valid lines.""" log_file = Log( logfile='haproxy/tests/files/2_ok_1_invalid.log', ) data = log_file.cmd_print() self.assertNotEqual('', data) lines = data.split('\n') self.assertEqual(len(lines), 3)
def test_cmd_average_waiting_time_no_wait(self): """Check that the average time waiting on queues returns the expected output when there are requests that did not wait at all (i.e. time_wait_queues is 0). """ log_file = Log( logfile='haproxy/tests/files/average_waiting_no_wait.log', ) data = log_file.cmd_average_waiting_time() self.assertEqual(data, 52.5)
def test_cmd_http_methods(self): """Check that the http methods command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/small.log', ) http_methods = log_file.cmd_http_methods() self.assertEqual(len(http_methods), 3) self.assertEqual(http_methods['GET'], 4) self.assertEqual(http_methods['POST'], 2) self.assertEqual(http_methods['HEAD'], 3)
def test_cmd_status_codes(self): """Check that the status codes command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/small.log', ) status_codes = log_file.cmd_status_codes_counter() self.assertEqual(len(status_codes), 3) self.assertEqual(status_codes['404'], 3) self.assertEqual(status_codes['200'], 2) self.assertEqual(status_codes['300'], 4)
def test_cmd_request_path_counter(self): """Check that the request path counter command reports as expected.""" log_file = Log(logfile='haproxy/tests/files/small.log') path_counter = log_file.cmd_request_path_counter() self.assertEqual(len(path_counter), 5) self.assertEqual(path_counter['/hello'], 3) self.assertEqual(path_counter['/world'], 2) self.assertEqual(path_counter['/free'], 2) self.assertEqual(path_counter['/fra'], 1) self.assertEqual(path_counter['/freitag'], 1)
def test_cmd_server_load(self): """Check that the server load counter command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/small.log', ) servers = log_file.cmd_server_load() self.assertEqual(len(servers), 3) self.assertEqual(servers['instance1'], 4) self.assertEqual(servers['instance2'], 3) self.assertEqual(servers['instance3'], 2)
def test_cmd_slow_requests(self): """Check that the slow requests command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/small.log', ) slow_requests = log_file.cmd_slow_requests() self.assertEqual(len(slow_requests), 5) slow_requests.sort() # sort them as the log analyzer sorts by dates self.assertEqual(slow_requests, [1293, 2936, 2942, 20095, 29408, ])
def test_cmd_ip_counter(self): """Check that the ip counter command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/small.log', ) ip_counter = log_file.cmd_ip_counter() self.assertEqual(len(ip_counter), 4) self.assertEqual(ip_counter['123.123.123.123'], 4) self.assertEqual(ip_counter['123.123.124.124'], 2) self.assertEqual(ip_counter['123.123.124.123'], 1) self.assertEqual(ip_counter['123.123.123.124'], 1)
def test_cmd_requests_per_minute(self): """Check that the requests per minute command reports as expected.""" log_file = Log(logfile='haproxy/tests/files/requests_per_minute.log') requests = log_file.cmd_requests_per_minute() self.assertEqual(len(requests), 5) self.assertEqual(requests[0], (datetime(2013, 12, 11, 11, 2), 8)) self.assertEqual(requests[1], (datetime(2013, 12, 11, 11, 3), 3)) self.assertEqual(requests[2], (datetime(2013, 12, 11, 11, 13), 5)) self.assertEqual(requests[3], (datetime(2013, 12, 11, 11, 52), 7)) self.assertEqual(requests[4], (datetime(2013, 12, 11, 12, 2), 9))
def test_cmd_top_request_paths(self): """Check that the top request paths command reports as expected.""" log_file = Log(logfile='haproxy/tests/files/top_paths.log', ) top_paths = log_file.cmd_top_request_paths() self.assertEqual(len(top_paths), 10) self.assertEqual(top_paths[0], ('/14', 6)) self.assertEqual(top_paths[1], ('/13', 4)) # as the 3rd and 4th have the same repetitions their order is unknown self.assertEqual(top_paths[2][1], 3) self.assertEqual(top_paths[3][1], 3) self.assertEqual(top_paths[4][1], 3) self.assertTrue(top_paths[2][0] in ( '/12', '/15', '/11', )) self.assertTrue(top_paths[3][0] in ( '/12', '/15', '/11', )) self.assertTrue(top_paths[4][0] in ( '/12', '/15', '/11', )) # the same as above for all the others other_paths = [ '/1', '/2', '/3', '/4', '/5', '/6', '/7', '/8', '/9', ] for path_info in top_paths[5:]: self.assertEqual(path_info[1], 2) self.assertTrue(path_info[0] in other_paths) # remove the other_ips to ensure all ips are there for position, current in enumerate(other_paths): if current == path_info[0]: del other_paths[position] break self.assertEqual(len(other_paths), 4)
def test_cmd_request_path_counter(self): """Check that the request path counter command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/small.log', ) path_counter = log_file.cmd_request_path_counter() self.assertEqual(len(path_counter), 5) self.assertEqual(path_counter['/hello'], 3) self.assertEqual(path_counter['/world'], 2) self.assertEqual(path_counter['/free'], 2) self.assertEqual(path_counter['/fra'], 1) self.assertEqual(path_counter['/freitag'], 1)
def main(args): if show_help(args): return # show the command list if args['list_commands']: print_commands() # no need to process further return # show the filter list if args['list_filters']: print_filters() # no need to process further return # create a Log instance and parse the log file log_file = Log( logfile=args['log'], ) # apply the time frame filter if args['start'] or args['delta']: start = args['start'] or '' delta = args['delta'] or '' filter_func = filters.filter_time_frame(start, delta) log_file = log_file.filter(filter_func) # apply all other filters given if args['filters']: for filter_data in args['filters']: arg = filter_data[1] or '' filter_func = getattr(filters, 'filter_{0}'.format(filter_data[0])) log_file = log_file.filter( filter_func(arg), reverse=args['negate_filter'], ) # run all commands for command in args['commands']: string = 'command: {0}'.format(command) print(string) print('=' * len(string)) cmd = getattr(log_file, 'cmd_{0}'.format(command)) result = cmd() print(result) return log_file # return the log_file object so that tests can inspect it
def test_total_lines(): """Check that the total amount of lines are always counted.""" log_file = Log(logfile='haproxy/tests/files/2_ok_1_invalid.log') _ = [x for x in log_file] assert log_file.total_lines == 3 assert log_file.valid_lines == 2 assert log_file.invalid_lines == 1
def test_start_and_end_attributes(start_str, start_obj, delta, end_obj): """Check that the start and end of attributes of Log objects are set as expected.""" log_file = Log('something', start=start_str, delta=delta) assert log_file.logfile == 'something' assert log_file.invalid_lines == 0 assert log_file.start == start_obj assert log_file.end == end_obj
def print_commands(): """Prints all commands available from Log with their description. """ dummy_log_file = Log() commands = Log.commands() commands.sort() for cmd in commands: cmd = getattr(dummy_log_file, 'cmd_{0}'.format(cmd)) description = cmd.__doc__ if description: description = re.sub(r'\n\s+', ' ', description) description = description.strip() print('{0}: {1}\n'.format(cmd.__name__, description))
def _parse_arg_commands(commands): input_commands = commands.split(',') available_commands = Log.commands() for cmd in input_commands: if cmd not in available_commands: msg = 'command "{0}" is not available. Use --list-commands to ' \ 'get a list of all available commands.' raise ValueError(msg.format(cmd)) return input_commands
def test_logfile_default_values(): """Check that the default values are set.""" log_file = Log('something') assert log_file.logfile == 'something' assert log_file.show_invalid is False assert log_file.invalid_lines == 0 assert log_file.valid_lines == 0 assert log_file.total_lines == 0 assert log_file.start is None assert log_file.end is None
def test_lines_sorted(self): """Check that after parsing a log file, the valid log lines are kept sorted to ease further work on them. """ log_file = Log(logfile='haproxy/tests/files/small.log') previous = log_file._valid_lines[0] previous_date = previous.accept_date for line in log_file._valid_lines[1:]: self.assertTrue(previous_date < line.accept_date)
def test_cmd_top_request_paths(self): """Check that the top request paths command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/top_paths.log', ) top_paths = log_file.cmd_top_request_paths() self.assertEqual(len(top_paths), 10) self.assertEqual(top_paths[0], ('/14', 6)) self.assertEqual(top_paths[1], ('/13', 4)) # as the 3rd and 4th have the same repetitions their order is unknown self.assertEqual(top_paths[2][1], 3) self.assertEqual(top_paths[3][1], 3) self.assertEqual(top_paths[4][1], 3) self.assertTrue(top_paths[2][0] in ('/12', '/15', '/11', )) self.assertTrue(top_paths[3][0] in ('/12', '/15', '/11', )) self.assertTrue(top_paths[4][0] in ('/12', '/15', '/11', )) # the same as above for all the others other_paths = [ '/1', '/2', '/3', '/4', '/5', '/6', '/7', '/8', '/9', ] for path_info in top_paths[5:]: self.assertEqual(path_info[1], 2) self.assertTrue(path_info[0] in other_paths) # remove the other_ips to ensure all ips are there for position, current in enumerate(other_paths): if current == path_info[0]: del other_paths[position] break self.assertEqual(len(other_paths), 4)
def test_pickle_exists(self): """Check that a pickle file is created after the first run.""" filename = 'haproxy/tests/files/average_waiting_aborted.log' pickle_file = '{0}.pickle'.format(filename) # pickle files does not exist self.assertFalse(os.path.exists(pickle_file)) Log(logfile=filename) # it does exist after parsing the file self.assertTrue(os.path.exists(pickle_file))
def test_returned_lines(tmp_path, http_line_factory, accept_date, start, delta, is_valid): """Check that lines are only returned if they are valid AND within the time frame.""" file_path = tmp_path / 'haproxy.log' line = '' if accept_date: line = http_line_factory(accept_date=accept_date).raw_line with open(file_path, 'w') as file_obj: file_obj.write(f'{line}\n') log_file = Log(file_path, start=start, delta=delta) lines = [x for x in log_file] assert bool(len(lines)) is is_valid
def test_cmd_queue_peaks_no_end(self): """Check that the queue peaks command reports as expected when the last log request did not have any queue. """ log_file = Log(logfile='haproxy/tests/files/queue_2.log') peaks = log_file.cmd_queue_peaks() self.assertEqual(len(peaks), 3) self.assertEqual(peaks[0]['peak'], 4) self.assertEqual(peaks[0]['span'], 5) self.assertEqual(peaks[1]['peak'], 19) self.assertEqual(peaks[1]['span'], 5) self.assertEqual(peaks[2]['peak'], 49) self.assertEqual(peaks[2]['span'], 3) self.assertTrue(peaks[0]['first'] < peaks[1]['first']) self.assertTrue(peaks[1]['first'] < peaks[2]['first']) self.assertTrue(peaks[0]['last'] < peaks[1]['last']) self.assertTrue(peaks[1]['last'] < peaks[2]['last'])
def test_arg_parser_list_commands_output(self): """Test that list commands argument outputs what's expected.""" arguments = ['--list-commands', ] data = parse_arguments(self.parser.parse_args(arguments)) test_output = NamedTemporaryFile(mode='w', delete=False) with RedirectStdout(stdout=test_output): main(data) with open(test_output.name, 'r') as output_file: output_text = output_file.read() for cmd in Log.commands(): self.assertIn(cmd, output_text)
def test_arg_parser_list_commands_output(self): """Test that list commands argument outputs what's expected.""" arguments = ['--list-commands'] data = parse_arguments(self.parser.parse_args(arguments)) test_output = NamedTemporaryFile(mode='w', delete=False) with RedirectStdout(stdout=test_output): main(data) with open(test_output.name, 'r') as output_file: output_text = output_file.read() for cmd in Log.commands(): self.assertIn(cmd, output_text)
def test_negate_filter(self): """Check that reversing a filter output works as expected.""" filter_func = filters.filter_ssl() log_file = Log( logfile='haproxy/tests/files/connection.log', ) # total number of log lines self.assertEqual(log_file.cmd_counter(), 12) # only SSL lines only_ssl = log_file.filter(filter_func) self.assertEqual(only_ssl.cmd_counter(), 7) # non SSL lines non_ssl = log_file.filter(filter_func, reverse=True) self.assertEqual(non_ssl.cmd_counter(), 5) # we did get all lines? self.assertEqual( log_file.cmd_counter(), only_ssl.cmd_counter() + non_ssl.cmd_counter() )
def test_cmd_top_ips(self): """Check that the top ips command reports as expected.""" log_file = Log( logfile='haproxy/tests/files/top_ips.log', ) top_ips = log_file.cmd_top_ips() self.assertEqual(len(top_ips), 10) self.assertEqual(top_ips[0], ('1.1.1.15', 6)) self.assertEqual(top_ips[1], ('1.1.1.11', 5)) # as the 3rd and 4th have the same repetitions their order is unknown self.assertEqual(top_ips[2][1], 4) self.assertEqual(top_ips[3][1], 4) self.assertTrue(top_ips[2][0] in ('1.1.1.10', '1.1.1.19')) self.assertTrue(top_ips[3][0] in ('1.1.1.10', '1.1.1.19')) # the same as above for all the others other_ips = [ '1.1.1.12', '1.1.1.13', '1.1.1.14', '1.1.1.16', '1.1.1.17', '1.1.1.18', ] for ip_info in top_ips[4:]: self.assertEqual(ip_info[1], 2) self.assertTrue(ip_info[0] in other_ips) # remove the other_ips to ensure all ips are there for position, current in enumerate(other_ips): if current == ip_info[0]: del other_ips[position] break self.assertEqual(other_ips, [])
def test_cmd_queue_peaks_no_end(self): """Check that the queue peaks command reports as expected when the last log request did not have any queue. """ log_file = Log( logfile='haproxy/tests/files/queue_2.log', ) peaks = log_file.cmd_queue_peaks() self.assertEqual(len(peaks), 3) self.assertEqual(peaks[0]['peak'], 4) self.assertEqual(peaks[0]['span'], 5) self.assertEqual(peaks[1]['peak'], 19) self.assertEqual(peaks[1]['span'], 5) self.assertEqual(peaks[2]['peak'], 49) self.assertEqual(peaks[2]['span'], 3) self.assertTrue(peaks[0]['first'] < peaks[1]['first']) self.assertTrue(peaks[1]['first'] < peaks[2]['first']) self.assertTrue(peaks[0]['last'] < peaks[1]['last']) self.assertTrue(peaks[1]['last'] < peaks[2]['last'])
def test_pickle_is_recreated(self): """Check that a pickle file is recreated if the log file is newer than the pickle file.""" filename = 'haproxy/tests/files/average_waiting_aborted.log' pickle_file = '{0}.pickle'.format(filename) # create the pickle file and get its modified time Log(logfile=filename) old_pickle_time = os.path.getmtime(pickle_file) # any second or nth run will not change the modified time Log(logfile=filename) second_old_pickle_time = os.path.getmtime(pickle_file) self.assertEqual(old_pickle_time, second_old_pickle_time) # 'update' the original log file sleep(1) # os.path.getmtime has a resolution up to seconds os.utime(filename, None) # the existing pickle file is discarded and a newer one will be created Log(logfile=filename) new_pickle_time = os.path.getmtime(pickle_file) self.assertTrue(new_pickle_time > old_pickle_time)
def main(args): if show_help(args): return # show the command list if args['list_commands']: print_commands() # no need to process further return # show the filter list if args['list_filters']: print_filters() # no need to process further return # initialize the log file log_file = Log( logfile=args['log'], start=args['start'], delta=args['delta'], show_invalid=args['invalid_lines'], ) # get the commands and filters to use filters_to_use = requested_filters(args) cmds_to_use = requested_commands(args) # double negation: when a user wants to negate the filters, # the argument parsing sets `negate_filter` to True, # but the filtering logic (the `all()`) returns True if the line meets all filters # so reversing whatever `negate_filter` has is what the user wants :) expected_filtering = True if args['negate_filter']: expected_filtering = False # process all log lines for line in log_file: if all((f(line) for f in filters_to_use)) is expected_filtering: for cmd in cmds_to_use: cmd(line) # print the results print('\nRESULTS\n') output = None if args['json']: output = 'json' for cmd in cmds_to_use: cmd.results(output=output)
def test_print_invalid_lines(tmp_path, http_line_factory, client_port, capsys): """Check that invalid lines are printed, if asked to do so.""" file_path = tmp_path / 'haproxy.log' line = http_line_factory(client_port=client_port).raw_line with open(file_path, 'w') as file_obj: file_obj.write(f'{line}\n') log_file = Log(file_path, show_invalid=True) _ = [x for x in log_file] output = capsys.readouterr().out # client port is stored after <client_ip>: so make sure # we match :<client_port> instead of just <client_port> which # can be part of a string by itself. if log_file.valid_lines == 1: assert ":" + client_port not in output else: assert ":" + client_port in output
def test_lines_validity(tmp_path, http_line_factory, accept_date): """Check that lines are either counted as valid or invalid.""" file_path = tmp_path / 'haproxy.log' line = '' if accept_date: line = http_line_factory(accept_date=accept_date).raw_line with open(file_path, 'w') as file_obj: file_obj.write(f'{line}\n') log_file = Log(file_path) _ = [x for x in log_file] assert log_file.total_lines == 1 if accept_date: assert log_file.valid_lines == 1 assert log_file.invalid_lines == 0 else: assert log_file.valid_lines == 0 assert log_file.invalid_lines == 1
def test_negate_filter(self): """Check that reversing a filter output works as expected.""" filter_func = filters.filter_ssl() log_file = Log(logfile='haproxy/tests/files/connection.log') # total number of log lines self.assertEqual(log_file.cmd_counter(), 12) # only SSL lines only_ssl = log_file.filter(filter_func) self.assertEqual(only_ssl.cmd_counter(), 7) # non SSL lines non_ssl = log_file.filter(filter_func, reverse=True) self.assertEqual(non_ssl.cmd_counter(), 5) # we did get all lines? self.assertEqual(log_file.cmd_counter(), only_ssl.cmd_counter() + non_ssl.cmd_counter())
def test_total_lines(self): """Check that even if some lines are not valid, 'total_lines' counts all of them. """ log_file = Log(logfile='haproxy/tests/files/2_ok_1_invalid.log') self.assertEqual(log_file.total_lines, 3)
def test_parsed(self): """Check that log files are parsed.""" log_file = Log( logfile='haproxy/tests/files/small.log' ) self.assertTrue(log_file.cmd_counter() > 0)