def test_close_on_reader_explicitly(self): f = FileReadBackwards(self.temp_file.name) it = iter(f) self.assertFalse( it.closed, msg="Iterator should not have its fp closed at this point.") f.close() self.assertTrue( it.closed, msg= "Iterator created by a reader should have its fp closed when the reader closes it." )
def test_behaves_as_classic(self): with FileReadBackwards(self.temp_file.name) as f: lines_read = deque() for l in f: lines_read.appendleft(l) f2 = FileReadBackwards(self.temp_file.name) lines_read2 = deque() for l2 in f2: lines_read2.appendleft(l2) self.assertEqual( lines_read, lines_read2, msg="The Context Manager way should behave exactly the same way as without using one.", )
def test_not_creating_new_iterator(self): with FileReadBackwards(self.temp_file.name) as f: it1 = iter(f) it2 = iter(f) self.assertTrue( it1 is it2, msg="FileReadBackwards will return the same iterator")
def test_file_with_new_lines_and_some_accented_characters_in_chunk_size( self): """Test a file with many new lines and a random text of size custom chunk_size.""" chunk_size = 3 b = b'\xc3\xa9' s = b.decode("utf-8") for number_of_new_lines in xrange(21): for new_line in new_lines: # test with variety of new lines temp_file = helper_create_temp_file( (l for l in [new_line * number_of_new_lines, s * chunk_size])) f = FileReadBackwards(temp_file.name, chunk_size=chunk_size) expected_lines = deque() for _ in xrange(number_of_new_lines): expected_lines.append("") expected_lines.append(s * chunk_size) lines_read = deque() for l in f: lines_read.appendleft(l) self.assertEqual( expected_lines, lines_read, msg= "Test with {0} of new line {1!r} followed by {2} of \\xc3\\xa9" .format(number_of_new_lines, new_line, chunk_size))
def test_file_with_varying_number_of_new_lines_and_some_text_in_chunk_size( self): """Test a file with varying number of new lines and text of size custom chunk_size.""" chunk_size = 3 s = "t" for number_of_new_lines in xrange(21): for new_line in new_lines: # test with variety of new lines temp_file = helper_create_temp_file( (l for l in [new_line * number_of_new_lines, s * chunk_size])) f = FileReadBackwards(temp_file.name, chunk_size=chunk_size) expected_lines = deque() for _ in xrange(number_of_new_lines): expected_lines.append("") expected_lines.append(s * chunk_size) lines_read = deque() for l in f: lines_read.appendleft(l) self.assertEqual( expected_lines, lines_read, msg= "Test with {0} of new line {1!r} followed by {2} of {3!r}". format(number_of_new_lines, new_line, chunk_size, s))
def test_close_on_reader_exit(self): with FileReadBackwards(self.temp_file.name) as f: it = iter(f) self.assertTrue( it.closed, msg="Iterator created by a reader should have its fp closed when the reader gets closed.", )
def test_with_completely_empty_file(self): """Test with a completely empty file.""" f = FileReadBackwards(self.empty_file.name) expected_lines = deque() lines_read = deque() for l in f: lines_read.appendleft(l) self.assertEqual(expected_lines, lines_read)
def test_close_on_reader_with_already_closed_iterator(self): with FileReadBackwards(self.temp_file.name) as f: it = iter(f) it.close() self.assertTrue( it.closed, msg="It should be okay to close (through the reader) an already closed iterator.", )
def test_close_on_iterator_exhausted(self): with FileReadBackwards(self.temp_file.name) as f: it = iter(f) for _ in it: pass self.assertTrue( it.closed, msg="The fp should be closed automatically when the iterator is exhausted.", )
def test_close_on_iterator(self): with FileReadBackwards(self.temp_file.name) as f: it = iter(f) for count, i in enumerate(it): if count == 2: break self.assertFalse( it.closed, msg="The fp should not be closed when not exhausted") it.close() self.assertTrue( it.closed, msg="Calling close() on the iterator should close it")
def test_file_with_one_line_of_text_readline(self): """Test a file with a single line of text followed by a new line.""" s = "Line0" for new_line in new_lines: temp_file = helper_create_temp_file((l for l in [s, new_line])) with FileReadBackwards(temp_file.name) as fp: l = fp.readline() expected_line = s + os.linesep self.assertEqual(l, expected_line) # the file contains only 1 line second_line = fp.readline() expected_second_line = "" self.assertEqual(second_line, expected_second_line)
def test_file_with_one_line_of_text_with_accented_char_followed_by_a_new_line( self): """Test a file with a single line of text with accented char followed by a new line.""" b = b'Caf\xc3\xa9' # accented e in utf-8 s = b.decode("utf-8") for new_line in new_lines: temp_file = helper_create_temp_file((l for l in [s, new_line])) f = FileReadBackwards(temp_file.name) expected_lines = deque([s]) lines_read = deque() for l in f: lines_read.appendleft(s) self.assertEqual(expected_lines, lines_read, msg="Test with {0!r} as newline".format(new_line))
def test_file_with_a_single_new_line_char_with_different_encodings(self): """Test a file with a single new line character.""" for encoding, new_line in itertools.product(supported_encodings, new_lines): temp_file = helper_create_temp_file((l for l in [new_line]), encoding=encoding) f = FileReadBackwards(temp_file.name) expected_lines = deque([""]) lines_read = deque() for l in f: lines_read.appendleft(l) self.assertEqual( expected_lines, lines_read, msg="Test with {0} encoding with {1!r} as newline".format( encoding, new_line))
def test_file_with_one_line_of_text_followed_by_a_new_line_with_different_encodings( self): """Test a file with just one line of text followed by a new line.""" for encoding, new_line in itertools.product(supported_encodings, new_lines): temp_file = helper_create_temp_file( (l for l in ["something{0}".format(new_line)]), encoding=encoding) f = FileReadBackwards(temp_file.name) expected_lines = deque(["something"]) lines_read = deque() for l in f: lines_read.appendleft(l) self.assertEqual( expected_lines, lines_read, msg="Test with {0} encoding with {1!r} as newline".format( encoding, new_line))
def test_file_with_two_lines_of_text_readline(self): """Test a file with a two lines of text followed by a new line.""" line0 = "Line0" line1 = "Line1" for new_line in new_lines: line0_with_n = "{}{}".format(line0, new_line) line1_with_n = "{}{}".format(line1, new_line) temp_file = helper_create_temp_file( (l for l in [line0_with_n, line1_with_n])) with FileReadBackwards(temp_file.name) as fp: l = fp.readline() expected_line = line1 + os.linesep self.assertEqual(l, expected_line) second_line = fp.readline() expected_second_line = line0 + os.linesep self.assertEqual(second_line, expected_second_line) # EOF third_line = fp.readline() expected_third_line = "" self.assertEqual(third_line, expected_third_line)
def test_cannot_iterate_when_closed(self): with FileReadBackwards(self.temp_file.name) as f: it = iter(f) it.close() for _ in it: self.fail(msg="An iterator should be exhausted when closed.")
def test_unsupported_encoding(self): """Test when users pass in unsupported encoding, NotImplementedError should be thrown.""" with self.assertRaises(NotImplementedError): _ = FileReadBackwards( self.empty_file.name, encoding="not-supported-encoding") # noqa: F841