def test_single_line_parser():
single_line_parser = SingleLineParser()
input_buffer = """test message 1
test message 2
test message 3
"""
single_line_parser.parse_buffer(content_buffer=input_buffer)
assert single_line_parser.msg_list == [
"test message 1\n", "test message 2\n", "test message 3\n"
]
def test_single_line_parser(tc_unittest):
single_line_parser = SingleLineParser(
tc_unittest.get_fake_logger_factory())
input_buffer = """test message 1
test message 2
test message 3
"""
single_line_parser.parse_buffer(content_buffer=input_buffer)
assert single_line_parser.msg_list == [
"test message 1\n", "test message 2\n", "test message 3\n"
]
def __init__(self, logger_factory, instance_paths):
self.__logger = logger_factory.create_logger("ConsoleLogReader")
self.__stderr_io = FileIO(logger_factory,
instance_paths.get_stderr_path())
self.__message_reader = MessageReader(logger_factory,
self.__stderr_io.read,
SingleLineParser(logger_factory))
def test_writing_popping_in_sequence(temp_file):
test_message = "test message 1\n"
writeable_file, readable_file = prepare_input_file(test_message, temp_file)
single_line_parser = SingleLineParser()
message_reader = MessageReader(readable_file.readline, single_line_parser)
assert message_reader.pop_messages(
counter=1) == test_message.splitlines(True)
test_message = "test message 2\ntest message 3\n"
writeable_file.write(test_message)
writeable_file.flush()
assert message_reader.pop_messages(
counter=2) == test_message.splitlines(True)
test_message = "test message 4\ntest message 5\n"
writeable_file.write(test_message)
writeable_file.flush()
assert message_reader.pop_messages(counter=1) == ["test message 4\n"]
assert message_reader.pop_messages(counter=1) == ["test message 5\n"]
test_message = "test message 6\ntest message 7\ntest message 8\ntest message 9\n"
writeable_file.write(test_message)
writeable_file.flush()
os.fsync(writeable_file.fileno())
assert message_reader.pop_messages(
counter=READ_ALL_AVAILABLE_MESSAGES) == test_message.splitlines(True)
test_message = "test message 10\n"
writeable_file.write(test_message)
writeable_file.flush()
assert message_reader.pop_messages(
counter=1) == test_message.splitlines(True)
def test_writing_popping_in_sequence(tc_unittest):
test_message = "test message 1\n"
writeable_file, readable_file = tc_unittest.prepare_input_file(test_message)
single_line_parser = SingleLineParser(tc_unittest.get_fake_logger_factory())
message_reader = MessageReader(tc_unittest.get_fake_logger_factory(), readable_file.read, single_line_parser)
assert message_reader.pop_messages(counter=1) == test_message.splitlines(True)
test_message = "test message 2\ntest message 3\n"
writeable_file.write(test_message)
writeable_file.flush()
assert message_reader.pop_messages(counter=2) == test_message.splitlines(True)
test_message = "test message 4\ntest message 5\n"
writeable_file.write(test_message)
writeable_file.flush()
assert message_reader.pop_messages(counter=1) == ["test message 4\n"]
assert message_reader.pop_messages(counter=1) == ["test message 5\n"]
test_message = "test message 6\ntest message 7\ntest message 8\ntest message 9\n"
writeable_file.write(test_message)
writeable_file.flush()
assert message_reader.pop_messages(counter=0) == test_message.splitlines(True)
test_message = "test message 10\n"
writeable_file.write(test_message)
writeable_file.flush()
assert message_reader.pop_messages(counter=1) == test_message.splitlines(True)
def test_buffer_and_parse(tc_unittest, input_message_counter, requested_message_counter, expected_result):
input_content = tc_unittest.get_utf8_test_messages(input_message_counter)
__writeable_file, readable_file = tc_unittest.prepare_input_file(input_content)
single_line_parser = SingleLineParser(tc_unittest.get_fake_logger_factory())
message_reader = MessageReader(tc_unittest.get_fake_logger_factory(), readable_file.read, single_line_parser)
assert message_reader._MessageReader__buffer_and_parse(requested_message_counter) is expected_result
assert single_line_parser.msg_list == input_content.splitlines(True)
def test_peek_messages(tc_unittest):
test_message = "test message 2\ntest message 3\n"
__writeable_file, readable_file = tc_unittest.prepare_input_file(test_message)
single_line_parser = SingleLineParser(tc_unittest.get_fake_logger_factory())
message_reader = MessageReader(tc_unittest.get_fake_logger_factory(), readable_file.read, single_line_parser)
assert message_reader.peek_messages(counter=2) == test_message.splitlines(True)
assert message_reader._MessageReader__parser.msg_list == test_message.splitlines(True)
def wait_file_content(self, content):
with self.path.open() as f:
message_reader = MessageReader(f.readline, SingleLineParser())
while True:
msg = message_reader.pop_messages(1)[0]
if content in msg:
return True
return False
def dd_read_logs(self, path, counter):
if not self.__reader:
io = self.__IOClass(self.__logger_factory, path)
io.wait_for_creation()
message_reader = MessageReader(
self.__logger_factory, io.read, SingleLineParser(self.__logger_factory)
)
self.__reader = message_reader
messages = self.__reader.pop_messages(counter)
self.__logger.print_io_content(path, messages, "Content has been read from")
return messages
def test_peek_messages(temp_file):
test_message = "test message 2\ntest message 3\n"
__writeable_file, readable_file = prepare_input_file(
test_message, temp_file)
single_line_parser = SingleLineParser()
message_reader = MessageReader(readable_file.read, single_line_parser)
assert message_reader.peek_messages(
counter=2) == test_message.splitlines(True)
assert message_reader._MessageReader__parser.msg_list == test_message.splitlines(
True)
def test_multiple_buffer_and_parse(tc_unittest):
input_content = tc_unittest.get_utf8_test_messages(2)
writeable_file, readable_file = tc_unittest.prepare_input_file(input_content)
single_line_parser = SingleLineParser(tc_unittest.get_fake_logger_factory())
message_reader = MessageReader(tc_unittest.get_fake_logger_factory(), readable_file.read, single_line_parser)
assert message_reader._MessageReader__buffer_and_parse(0) is False
writeable_file.write(input_content)
writeable_file.flush()
assert message_reader._MessageReader__buffer_and_parse(0) is False
assert single_line_parser.msg_list == input_content.splitlines(True) * 2
def test_buffer_and_parse(test_message, temp_file, input_message_counter,
requested_message_counter, expected_result):
input_content = test_message * input_message_counter
__writeable_file, readable_file = prepare_input_file(
input_content, temp_file)
single_line_parser = SingleLineParser()
message_reader = MessageReader(readable_file.read, single_line_parser)
assert message_reader._MessageReader__buffer_and_parse(
requested_message_counter) is expected_result
assert single_line_parser.msg_list == input_content.splitlines(True)
def dd_read_logs(self, path, counter):
if not self.__reader:
io = self.__IOClass(path)
io.wait_for_creation()
message_reader = MessageReader(io.read, SingleLineParser())
self.__reader = message_reader
messages = self.__reader.pop_messages(counter)
read_description = "Content has been read from\nresource: {}\ncontent: {}\n".format(
path, messages)
logger.info(read_description)
return messages
def test_pop_messages(tc_unittest, input_message, requested_message_counter, popped_message, remaining_message):
__writeable_file, readable_file = tc_unittest.prepare_input_file(input_message)
single_line_parser = SingleLineParser(tc_unittest.get_fake_logger_factory())
message_reader = MessageReader(tc_unittest.get_fake_logger_factory(), readable_file.read, single_line_parser)
if requested_message_counter > input_message.count("\n"):
with pytest.raises(AssertionError):
message_reader.pop_messages(requested_message_counter, timeout=0.1)
else:
assert message_reader.pop_messages(requested_message_counter) == popped_message
assert message_reader._MessageReader__parser.msg_list == remaining_message
def dd_read_logs(self, path, counter):
if path not in self.__native_driver_io_collection.keys():
native_driver_io = self.__native_driver_io_ref(self.__logger_factory, path)
native_driver_io.wait_for_creation()
message_reader = MessageReader(
self.__logger_factory, native_driver_io.read, SingleLineParser(self.__logger_factory)
)
self.__native_driver_io_collection.update({path: message_reader})
message_reader = self.__native_driver_io_collection[path]
messages = message_reader.pop_messages(counter)
self.__logger.print_io_content(path, messages, "Content has been read from")
return messages
def test_multiple_buffer_and_parse(test_message, temp_file):
input_content = test_message * 2
writeable_file, readable_file = prepare_input_file(input_content,
temp_file)
single_line_parser = SingleLineParser()
message_reader = MessageReader(readable_file.read, single_line_parser)
assert message_reader._MessageReader__buffer_and_parse(0) is False
writeable_file.write(input_content)
writeable_file.flush()
assert message_reader._MessageReader__buffer_and_parse(0) is False
assert single_line_parser.msg_list == input_content.splitlines(True) * 2
def test_popping_in_sequence(tc_unittest):
input_content = tc_unittest.get_utf8_test_messages(counter=10)
__writeable_file, readable_file = tc_unittest.prepare_input_file(input_content)
single_line_parser = SingleLineParser(tc_unittest.get_fake_logger_factory())
message_reader = MessageReader(tc_unittest.get_fake_logger_factory(), readable_file.read, single_line_parser)
input_content_list = input_content.splitlines(True)
assert message_reader.pop_messages(counter=2) == input_content_list[0:2]
assert message_reader.pop_messages(counter=2) == input_content_list[2:4]
assert message_reader.pop_messages(counter=2) == input_content_list[4:6]
assert message_reader.pop_messages(counter=2) == input_content_list[6:8]
assert message_reader.pop_messages(counter=2) == input_content_list[8:10]
def test_read_all_messages():
def read_generator():
yield "" # eof
yield "second\n"
yield "third\n"
yield "" # eof
single_line_parser = SingleLineParser()
generator = read_generator()
message_reader = MessageReader(lambda: next(generator), single_line_parser)
assert len(message_reader.pop_messages(counter=READ_ALL_MESSAGES)) == 0
assert len(message_reader.pop_messages(counter=READ_ALL_MESSAGES)) == 2
def test_popping_in_sequence(test_message, temp_file):
input_content = test_message * 10
__writeable_file, readable_file = prepare_input_file(
input_content, temp_file)
single_line_parser = SingleLineParser()
message_reader = MessageReader(readable_file.read, single_line_parser)
input_content_list = input_content.splitlines(True)
assert message_reader.pop_messages(counter=2) == input_content_list[0:2]
assert message_reader.pop_messages(counter=2) == input_content_list[2:4]
assert message_reader.pop_messages(counter=2) == input_content_list[4:6]
assert message_reader.pop_messages(counter=2) == input_content_list[6:8]
assert message_reader.pop_messages(counter=2) == input_content_list[8:10]
def test_single_line_parser_parsing_multiple_times():
single_line_parser = SingleLineParser()
input_buffer = """test message 1
"""
single_line_parser.parse_buffer(content_buffer=input_buffer)
input_buffer2 = """test message 2
"""
single_line_parser.parse_buffer(content_buffer=input_buffer2)
assert single_line_parser.msg_list == [
"test message 1\n", "test message 2\n"
]
def test_single_line_parser_parsing_multiple_times(tc_unittest):
single_line_parser = SingleLineParser(
tc_unittest.get_fake_logger_factory())
input_buffer = """test message 1
"""
single_line_parser.parse_buffer(content_buffer=input_buffer)
input_buffer2 = """test message 2
"""
single_line_parser.parse_buffer(content_buffer=input_buffer2)
assert single_line_parser.msg_list == [
"test message 1\n", "test message 2\n"
]
def test_single_line_parser_chunks():
single_line_parser = SingleLineParser()
single_line_parser.parse_buffer(content_buffer="first")
single_line_parser.parse_buffer(content_buffer="second\n")
assert single_line_parser.msg_list == ["firstsecond\n"]
def test_single_line_parser_no_line_end():
single_line_parser = SingleLineParser()
input_buffer = "test message 1"
single_line_parser.parse_buffer(content_buffer=input_buffer)
assert single_line_parser.msg_list == []
def __init__(self, instance_paths):
self.__stderr_io = FileIO(instance_paths.get_stderr_path())
self.__message_reader = MessageReader(self.__stderr_io.readline,
SingleLineParser())
self.__console_log_path = instance_paths.get_stderr_path()
def test_single_line_parser_no_line_end(tc_unittest):
single_line_parser = SingleLineParser(
tc_unittest.get_fake_logger_factory())
input_buffer = "test message 1"
single_line_parser.parse_buffer(content_buffer=input_buffer)
assert single_line_parser.msg_list == []