move rest the tests over to py.test functions, pep8

Author: tony

tests/buffer/test_buffer.py

@@ -2,101 +2,110 @@
 
 from prompt_toolkit.buffer import Buffer
 
-import unittest
+import pytest
 
 
-class BufferTest(unittest.TestCase):
-    def setUp(self):
-        self.buffer = Buffer()
+@pytest.fixture
+def _buffer():
+    return Buffer()
 
-    def test_initial(self):
-        self.assertEqual(self.buffer.text, '')
-        self.assertEqual(self.buffer.cursor_position, 0)
 
-    def test_insert_text(self):
-        self.buffer.insert_text('some_text')
-        self.assertEqual(self.buffer.text, 'some_text')
-        self.assertEqual(self.buffer.cursor_position, len('some_text'))
+def test_initial(_buffer):
+    assert _buffer.text == ''
+    assert _buffer.cursor_position == 0
 
-    def test_cursor_movement(self):
-        self.buffer.insert_text('some_text')
-        self.buffer.cursor_left()
-        self.buffer.cursor_left()
-        self.buffer.cursor_left()
-        self.buffer.cursor_right()
-        self.buffer.insert_text('A')
 
-        self.assertEqual(self.buffer.text, 'some_teAxt')
-        self.assertEqual(self.buffer.cursor_position, len('some_teA'))
+def test_insert_text(_buffer):
+    _buffer.insert_text('some_text')
+    assert _buffer.text == 'some_text'
+    assert _buffer.cursor_position == len('some_text')
 
-    def test_backspace(self):
-        self.buffer.insert_text('some_text')
-        self.buffer.cursor_left()
-        self.buffer.cursor_left()
-        self.buffer.delete_before_cursor()
 
-        self.assertEqual(self.buffer.text, 'some_txt')
-        self.assertEqual(self.buffer.cursor_position, len('some_t'))
+def test_cursor_movement(_buffer):
+    _buffer.insert_text('some_text')
+    _buffer.cursor_left()
+    _buffer.cursor_left()
+    _buffer.cursor_left()
+    _buffer.cursor_right()
+    _buffer.insert_text('A')
 
-    def test_cursor_up(self):
-        # Cursor up to a line thats longer.
-        self.buffer.insert_text('long line1\nline2')
-        self.buffer.cursor_up()
+    assert _buffer.text == 'some_teAxt'
+    assert _buffer.cursor_position == len('some_teA')
 
-        self.assertEqual(self.buffer.document.cursor_position, 5)
 
-        # Going up when already at the top.
-        self.buffer.cursor_up()
-        self.assertEqual(self.buffer.document.cursor_position, 5)
+def test_backspace(_buffer):
+    _buffer.insert_text('some_text')
+    _buffer.cursor_left()
+    _buffer.cursor_left()
+    _buffer.delete_before_cursor()
 
-        # Going up to a line that's shorter.
-        self.buffer.reset()
-        self.buffer.insert_text('line1\nlong line2')
+    assert _buffer.text == 'some_txt'
+    assert _buffer.cursor_position == len('some_t')
 
-        self.buffer.cursor_up()
-        self.assertEqual(self.buffer.document.cursor_position, 5)
 
-    def test_cursor_down(self):
-        self.buffer.insert_text('line1\nline2')
-        self.buffer.cursor_position = 3
+def test_cursor_up(_buffer):
+    # Cursor up to a line thats longer.
+    _buffer.insert_text('long line1\nline2')
+    _buffer.cursor_up()
 
-        # Normally going down
-        self.buffer.cursor_down()
-        self.assertEqual(self.buffer.document.cursor_position, len('line1\nlin'))
+    assert _buffer.document.cursor_position == 5
 
-        # Going down to a line that's storter.
-        self.buffer.reset()
-        self.buffer.insert_text('long line1\na\nb')
-        self.buffer.cursor_position = 3
+    # Going up when already at the top.
+    _buffer.cursor_up()
+    assert _buffer.document.cursor_position == 5
 
-        self.buffer.cursor_down()
-        self.assertEqual(self.buffer.document.cursor_position, len('long line1\na'))
+    # Going up to a line that's shorter.
+    _buffer.reset()
+    _buffer.insert_text('line1\nlong line2')
 
-    def test_join_next_line(self):
-        self.buffer.insert_text('line1\nline2\nline3')
-        self.buffer.cursor_up()
-        self.buffer.join_next_line()
+    _buffer.cursor_up()
+    assert _buffer.document.cursor_position == 5
 
-        self.assertEqual(self.buffer.text, 'line1\nline2 line3')
 
-        # Test when there is no '\n' in the text
-        self.buffer.reset()
-        self.buffer.insert_text('line1')
-        self.buffer.cursor_position = 0
-        self.buffer.join_next_line()
+def test_cursor_down(_buffer):
+    _buffer.insert_text('line1\nline2')
+    _buffer.cursor_position = 3
 
-        self.assertEqual(self.buffer.text, 'line1')
+    # Normally going down
+    _buffer.cursor_down()
+    assert _buffer.document.cursor_position == len('line1\nlin')
 
-    def test_newline(self):
-        self.buffer.insert_text('hello world')
-        self.buffer.newline()
+    # Going down to a line that's storter.
+    _buffer.reset()
+    _buffer.insert_text('long line1\na\nb')
+    _buffer.cursor_position = 3
 
-        self.assertEqual(self.buffer.text, 'hello world\n')
+    _buffer.cursor_down()
+    assert _buffer.document.cursor_position == len('long line1\na')
 
-    def test_swap_characters_before_cursor(self):
-        self.buffer.insert_text('hello world')
-        self.buffer.cursor_left()
-        self.buffer.cursor_left()
-        self.buffer.swap_characters_before_cursor()
 
-        self.assertEqual(self.buffer.text, 'hello wrold')
+def test_join_next_line(_buffer):
+    _buffer.insert_text('line1\nline2\nline3')
+    _buffer.cursor_up()
+    _buffer.join_next_line()
+
+    assert _buffer.text == 'line1\nline2 line3'
+
+    # Test when there is no '\n' in the text
+    _buffer.reset()
+    _buffer.insert_text('line1')
+    _buffer.cursor_position = 0
+    _buffer.join_next_line()
+
+    assert _buffer.text == 'line1'
+
+
+def test_newline(_buffer):
+    _buffer.insert_text('hello world')
+    _buffer.newline()
+
+    assert _buffer.text == 'hello world\n'
+
+
+def test_swap_characters_before_cursor(_buffer):
+    _buffer.insert_text('hello world')
+    _buffer.cursor_left()
+    _buffer.cursor_left()
+    _buffer.swap_characters_before_cursor()
+
+    assert _buffer.text == 'hello wrold'

tests/document/test_document.py

@@ -1,65 +1,74 @@
 from __future__ import unicode_literals
 
+import pytest
+
 from prompt_toolkit.document import Document
 
-import unittest
+
+@pytest.fixture
+def document():
+    return Document(
+        'line 1\n' +
+        'line 2\n' +
+        'line 3\n' +
+        'line 4\n',
+        len('line 1\n' + 'lin')
+    )
+
+
+def test_current_char(document):
+    assert document.current_char == 'e'
+
+
+def test_text_before_cursor(document):
+    assert document.text_before_cursor == 'line 1\nlin'
+
+
+def test_text_after_cursor(document):
+    assert document.text_after_cursor == 'e 2\n' + \
+        'line 3\n' + \
+        'line 4\n'
+
+
+def test_lines(document):
+    assert document.lines == [
+        'line 1',
+        'line 2',
+        'line 3',
+        'line 4', '']
 
 
-class DocumentTest(unittest.TestCase):
-    def setUp(self):
-        self.document = Document(
-            'line 1\n' +
-            'line 2\n' +
-            'line 3\n' +
-            'line 4\n',
-            len('line 1\n' + 'lin')
-        )
+def test_line_count(document):
+    assert document.line_count == 5
 
-    def test_current_char(self):
-        self.assertEqual(self.document.current_char, 'e')
 
-    def test_text_before_cursor(self):
-        self.assertEqual(self.document.text_before_cursor, 'line 1\nlin')
+def test_current_line_before_cursor(document):
+    assert document.current_line_before_cursor == 'lin'
 
-    def test_text_after_cursor(self):
-        self.assertEqual(self.document.text_after_cursor,
-                         'e 2\n' +
-                         'line 3\n' +
-                         'line 4\n')
 
-    def test_lines(self):
-        self.assertEqual(self.document.lines, [
-                         'line 1',
-                         'line 2',
-                         'line 3',
-                         'line 4', ''])
+def test_current_line_after_cursor(document):
+    assert document.current_line_after_cursor == 'e 2'
 
-    def test_line_count(self):
-        self.assertEqual(self.document.line_count, 5)
 
-    def test_current_line_before_cursor(self):
-        self.assertEqual(self.document.current_line_before_cursor, 'lin')
+def test_current_line(document):
+    assert document.current_line == 'line 2'
 
-    def test_current_line_after_cursor(self):
-        self.assertEqual(self.document.current_line_after_cursor, 'e 2')
 
-    def test_current_line(self):
-        self.assertEqual(self.document.current_line, 'line 2')
+def test_cursor_position(document):
+    assert document.cursor_position_row == 1
+    assert document.cursor_position_col == 3
 
-    def test_cursor_position(self):
-        self.assertEqual(self.document.cursor_position_row, 1)
-        self.assertEqual(self.document.cursor_position_col, 3)
+    d = Document('', 0)
+    assert d.cursor_position_row == 0
+    assert d.cursor_position_col == 0
 
-        d = Document('', 0)
-        self.assertEqual(d.cursor_position_row, 0)
-        self.assertEqual(d.cursor_position_col, 0)
 
-    def test_translate_index_to_position(self):
-        pos = self.document.translate_index_to_position(
-            len('line 1\nline 2\nlin'))
+def test_translate_index_to_position(document):
+    pos = document.translate_index_to_position(
+        len('line 1\nline 2\nlin'))
 
-        self.assertEqual(pos[0], 2)
-        self.assertEqual(pos[1], 3)
+    assert pos[0] == 2
+    assert pos[1] == 3
 
-        pos = self.document.translate_index_to_position(0)
-        self.assertEqual(pos, (0, 0))
+    pos = document.translate_index_to_position(0)
+    assert pos == (0, 0)