TestIntegration.test_big_file() - Code Metrics - Inspection of "fixed test" - timeyyy/pytknvim - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e78923...5c165f )

by timothy

created 2016-05-25 19:27 UTC

TestIntegration.test_big_file() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
cc	1
dl	0
loc	24
rs	8.9713
c	3
b	1
f	0

'''
Neovim ui api is likely to change,
also i do not understand really how and what it tries to do,
it feels very granular and clunky.
Makes it hard to do unit testing.
Focuising on Integration testing...
'''

import os
import time
import _thread as thread
from itertools import count

import pytest

from pytknvim.ui_bridge import UIBridge
from pytknvim.tk_ui import NvimTk
from pytknvim.util import attach_headless
from pytknvim.tests.util import compare_screens, send_tk_key
from pytknvim.tests.util import STATUS_BAR_HEIGHT
from pytknvim.util import rand_str


MAX_SCROLL = 10


class MockNvimText(NvimTk):

    '''
    Our Nvim capable tkinter text widget
    '''

    def thread_ui(self):
        '''starts our us threaded so we can run tests'''
        # scroll test will always check scrolling
        named_pipe = '/tmp/nvim{0}'.format(rand_str(16))
        nvim = attach_headless(('-u', 'NONE'), path=named_pipe)
        ui = self
        self._bridge = UIBridge()
        thread.start_new_thread(self._bridge.connect,
                                (nvim, ui))

        self.test_nvim = attach_headless(path=named_pipe)
        time.sleep(2)
        self.max_scroll = MAX_SCROLL


class VimCommands():
    '''
    Just for readablility
    '''
    def v_insert_mode(self):
        self.send_tk_key('i')

    def v_normal_mode(self):
        self.send_tk_key('Esc')

    def v_back(self):
        self.v_normal_mode()
        self.send_tk_key('b')

    def v_delete_line(self):
        self.v_normal_mode()
        self.send_tk_key('d')
        self.send_tk_key('d')

    def v_up(self):
        self.v_normal_mode()
        self.send_tk_key('k')

    def v_down(self):
        self.v_normal_mode()
        self.send_tk_key('j')

    def v_undo(self):
        self.v_normal_mode()
        self.send_tk_key('u')

    def v_page_down(self):
        self.v_normal_mode()
        self.send_tk_key('G')

    def v_page_up(self):
        self.v_normal_mode()
        self.send_tk_key('g')
        self.send_tk_key('g')

    def v_jump(self, pos):
        self.v_normal_mode()
        self.send_tk_key(*"{}G".format(pos))
        self.send_tk_key('Enter')


class TestIntegration(VimCommands):


    def setup_class(cls):
        cls.nvimtk = MockNvimText()
        cls.nvimtk.thread_ui()
        # This one has to be used because of threads and locks
        cls.nvim = cls.nvimtk.test_nvim
    # TODO
    # Our compare_screen function doesn't work with number set
        cls.nvim.command("set nonumber")
        cls.nvim.command("set norelativenumber")
        cls.nvim.command("set noswapfile")

    def teardown_class(cls):
        # Have to figure out how to teardown properlly
        # Pipes still breaking...
        cls.nvimtk.quit()
        time.sleep(0.2)


    def teardown_method(self, method):
        '''delete everything so we get a clean slate'''
        self.send_tk_key('Esc')
        buf = self.nvimtk.test_nvim.buffers[0]
        buf[:] = [""]


    def send_tk_key(self, *keys, modifyers=None):
        for key in keys:
            mod = None
            if type(key) in (tuple, list):
                key, mod = key
            send_tk_key(self.nvimtk, key, mod)


    def compare_screens(self):
        compare_screens(self.nvimtk)


    @pytest.mark.simple
    def test_load(self):
        self.compare_screens()


    @pytest.mark.simple
    def test_basic_insert(self):
        self.v_insert_mode()
        self.compare_screens()
        self.send_tk_key('a')
        self.compare_screens()
        self.send_tk_key('b', 'c', 'd', 'e')
        self.compare_screens()


    @pytest.mark.simple
    def test_enter_key(self):
        self.v_insert_mode()
        self.send_tk_key('b', 'c', 'd', 'e')
        self.send_tk_key('Enter')
        self.send_tk_key('Enter')
        self.compare_screens()
        self.send_tk_key('f', 'g', 'h')
        self.compare_screens()
        self.v_back()
        self.v_insert_mode()
        self.send_tk_key('1','2','3')
        self.send_tk_key('Enter')
        self.compare_screens()


    @pytest.mark.simple
    def test_delete_line(self):
        self.v_insert_mode()
        self.send_tk_key('o', 'n', 'e')
        self.v_delete_line()
        self.compare_screens()
        self.v_insert_mode()
        self.send_tk_key('o', 'n', 'e')
        self.send_tk_key('Enter')
        self.send_tk_key('t', 'w', 'o')
        self.send_tk_key('Enter')
        self.send_tk_key('t', 'h', 'r', 'e', 'e')
        self.compare_screens()
        self.v_delete_line()
        self.compare_screens()
        self.v_undo()
        self.compare_screens()


    def test_o_and_shift_o(self):
        self.v_insert_mode()
        self.send_tk_key('1')
        self.v_normal_mode()
        # Open onto new line
        self.send_tk_key('o')
        self.send_tk_key('3')
        self.compare_screens()
        self.v_normal_mode()
        #  Open onto previous line
        self.send_tk_key('O')
        self.send_tk_key('2')
        self.compare_screens()
        # The end state of this tests should be
        # 1
        # 2
        #
        # 3


    def test_scroll(self):
        # Force a scroll of an amount then compare_screens
        def _do(to_top):
            self.compare_screens()
            for i in range(0, to_top):
                self.v_up()
            self.compare_screens()
            for i in range(0, to_top):
                self.v_down()
            self.compare_screens()

        # TODO GET THIS DYNAMICALLY
        STATUS_BAR_HEIGHT = 3
        for i in count(1):
            self.v_page_down()
            self.v_insert_mode()
            scrolled = i\
                       - self.nvimtk.current_rows\
                       + STATUS_BAR_HEIGHT
            self.send_tk_key(*str(i-1))
            self.send_tk_key('Enter')

            self.nvimtk.max_scroll = 50
            if scrolled in (1, 2, self.nvimtk.max_scroll):
                to_top = self.nvimtk.current_rows + scrolled
                _do(to_top)
            if scrolled == self.nvimtk.max_scroll:
                break


    def test_page_up_down(self):
        def _do(to_top):
            self.compare_screens()
            self.v_page_up()
            self.compare_screens()
            self.v_page_down()
            self.compare_screens()

        for i in count(1):
            self.v_page_down()
            self.v_insert_mode()
            scrolled = i\
                       - self.nvimtk.current_rows\
                       + STATUS_BAR_HEIGHT
            self.send_tk_key(*str(i-1))
            self.send_tk_key('Enter')

            # Make sure our last jump covers an entire page
            last_scroll = old_scroll = self.nvimtk.max_scroll
            if last_scroll < self.nvimtk.current_rows:
                last_scroll = self.nvimtk.current_rows + 1
                self.nvimtk.max_scroll = last_scroll

            if scrolled in (1, 2, last_scroll):
                to_top = self.nvimtk.current_rows + scrolled
                time.sleep(1)
                _do(to_top)
            if scrolled == last_scroll:
                self.nvimtk.max_scroll = old_scroll
                break


    def test_big_file(self):
        '''
        doesn't test anything that our other tests doesn't,
        but just paves the way for testing a file
        '''
        test_file = os.path.join(os.path.dirname(__file__),
                                 'test_file')
        self.v_normal_mode()
        self.send_tk_key(*':e! '+test_file)
        self.send_tk_key('Enter')
        # Give time for actions to take place
        time.sleep(1)
        self.compare_screens()
        # TODO READ LEN OF FILE
        old_max = self.nvimtk.max_scroll
        self.nvimtk.max_scroll = 500
        self.v_page_down()
        time.sleep(0.5)
        self.compare_screens()
        self.v_page_up()
        time.sleep(0.5)
        self.compare_screens()
        self.nvimtk.max_sroll = old_max
        self.nvim.command('bwipeout')


    def test_number(self):
        to_test = ('load', 'basic_insert', 'enter_key')
        self.nvim.command("set nonumber")
        self.nvim.command("set relativenumber")
        time.sleep(0.5)
        for test in to_test:
            method = getattr(self, 'test_' + test)
            method()
            self.teardown_method(method)


1			'''
2			Neovim ui api is likely to change,
3			also i do not understand really how and what it tries to do,
4			it feels very granular and clunky.
5			Makes it hard to do unit testing.
6			Focuising on Integration testing...
7			'''
8
9			import os
10			import time
11			import _thread as thread
12			from itertools import count
13
14			import pytest
15
16			from pytknvim.ui_bridge import UIBridge
17			from pytknvim.tk_ui import NvimTk
18			from pytknvim.util import attach_headless
19			from pytknvim.tests.util import compare_screens, send_tk_key
20			from pytknvim.tests.util import STATUS_BAR_HEIGHT
21			from pytknvim.util import rand_str
22
23
24			MAX_SCROLL = 10
25
26
27			class MockNvimText(NvimTk):
28
29			'''
30			Our Nvim capable tkinter text widget
31			'''
32
33			def thread_ui(self):
34			'''starts our us threaded so we can run tests'''
35			# scroll test will always check scrolling
36			named_pipe = '/tmp/nvim{0}'.format(rand_str(16))
37			nvim = attach_headless(('-u', 'NONE'), path=named_pipe)
38			ui = self
39			self._bridge = UIBridge()
40			thread.start_new_thread(self._bridge.connect,
41			(nvim, ui))
42
43			self.test_nvim = attach_headless(path=named_pipe)
44			time.sleep(2)
45			self.max_scroll = MAX_SCROLL
46
47
48			class VimCommands():
49			'''
50			Just for readablility
51			'''
52			def v_insert_mode(self):
53			self.send_tk_key('i')
54
55			def v_normal_mode(self):
56			self.send_tk_key('Esc')
57
58			def v_back(self):
59			self.v_normal_mode()
60			self.send_tk_key('b')
61
62			def v_delete_line(self):
63			self.v_normal_mode()
64			self.send_tk_key('d')
65			self.send_tk_key('d')
66
67			def v_up(self):
68			self.v_normal_mode()
69			self.send_tk_key('k')
70
71			def v_down(self):
72			self.v_normal_mode()
73			self.send_tk_key('j')
74
75			def v_undo(self):
76			self.v_normal_mode()
77			self.send_tk_key('u')
78
79			def v_page_down(self):
80			self.v_normal_mode()
81			self.send_tk_key('G')
82
83			def v_page_up(self):
84			self.v_normal_mode()
85			self.send_tk_key('g')
86			self.send_tk_key('g')
87
88			def v_jump(self, pos):
89			self.v_normal_mode()
90			self.send_tk_key(*"{}G".format(pos))
91			self.send_tk_key('Enter')
92
93
94			class TestIntegration(VimCommands):
95
96
97			def setup_class(cls):
98			cls.nvimtk = MockNvimText()
99			cls.nvimtk.thread_ui()
100			# This one has to be used because of threads and locks
101			cls.nvim = cls.nvimtk.test_nvim
102			# TODO
103			# Our compare_screen function doesn't work with number set
104			cls.nvim.command("set nonumber")
105			cls.nvim.command("set norelativenumber")
106			cls.nvim.command("set noswapfile")
107
108			def teardown_class(cls):
109			# Have to figure out how to teardown properlly
110			# Pipes still breaking...
111			cls.nvimtk.quit()
112			time.sleep(0.2)
113
114
115			def teardown_method(self, method):
116			'''delete everything so we get a clean slate'''
117			self.send_tk_key('Esc')
118			buf = self.nvimtk.test_nvim.buffers[0]
119			buf[:] = [""]
120
121
122			def send_tk_key(self, *keys, modifyers=None):
123			for key in keys:
124			mod = None
125			if type(key) in (tuple, list):
126			key, mod = key
127			send_tk_key(self.nvimtk, key, mod)
128
129
130			def compare_screens(self):
131			compare_screens(self.nvimtk)
132
133
134			@pytest.mark.simple
135			def test_load(self):
136			self.compare_screens()
137
138
139			@pytest.mark.simple
140			def test_basic_insert(self):
141			self.v_insert_mode()
142			self.compare_screens()
143			self.send_tk_key('a')
144			self.compare_screens()
145			self.send_tk_key('b', 'c', 'd', 'e')
146			self.compare_screens()
147
148
149			@pytest.mark.simple
150			def test_enter_key(self):
151			self.v_insert_mode()
152			self.send_tk_key('b', 'c', 'd', 'e')
153			self.send_tk_key('Enter')
154			self.send_tk_key('Enter')
155			self.compare_screens()
156			self.send_tk_key('f', 'g', 'h')
157			self.compare_screens()
158			self.v_back()
159			self.v_insert_mode()
160			self.send_tk_key('1','2','3')
161			self.send_tk_key('Enter')
162			self.compare_screens()
163
164
165			@pytest.mark.simple
166			def test_delete_line(self):
167			self.v_insert_mode()
168			self.send_tk_key('o', 'n', 'e')
169			self.v_delete_line()
170			self.compare_screens()
171			self.v_insert_mode()
172			self.send_tk_key('o', 'n', 'e')
173			self.send_tk_key('Enter')
174			self.send_tk_key('t', 'w', 'o')
175			self.send_tk_key('Enter')
176			self.send_tk_key('t', 'h', 'r', 'e', 'e')
177			self.compare_screens()
178			self.v_delete_line()
179			self.compare_screens()
180			self.v_undo()
181			self.compare_screens()
182
183
184			def test_o_and_shift_o(self):
185			self.v_insert_mode()
186			self.send_tk_key('1')
187			self.v_normal_mode()
188			# Open onto new line
189			self.send_tk_key('o')
190			self.send_tk_key('3')
191			self.compare_screens()
192			self.v_normal_mode()
193			# Open onto previous line
194			self.send_tk_key('O')
195			self.send_tk_key('2')
196			self.compare_screens()
197			# The end state of this tests should be
198			# 1
199			# 2
200			#
201			# 3
202
203
204			def test_scroll(self):
205			# Force a scroll of an amount then compare_screens
206			def _do(to_top):
207			self.compare_screens()
208			for i in range(0, to_top):
209			self.v_up()
210			self.compare_screens()
211			for i in range(0, to_top):
212			self.v_down()
213			self.compare_screens()
214
215			# TODO GET THIS DYNAMICALLY
216			STATUS_BAR_HEIGHT = 3
217			for i in count(1):
218			self.v_page_down()
219			self.v_insert_mode()
220			scrolled = i\
221			- self.nvimtk.current_rows\
222			+ STATUS_BAR_HEIGHT
223			self.send_tk_key(*str(i-1))
224			self.send_tk_key('Enter')
225
226			self.nvimtk.max_scroll = 50
227			if scrolled in (1, 2, self.nvimtk.max_scroll):
228			to_top = self.nvimtk.current_rows + scrolled
229			_do(to_top)
230			if scrolled == self.nvimtk.max_scroll:
231			break
232
233
234			def test_page_up_down(self):
235			def _do(to_top):
236			self.compare_screens()
237			self.v_page_up()
238			self.compare_screens()
239			self.v_page_down()
240			self.compare_screens()
241
242			for i in count(1):
243			self.v_page_down()
244			self.v_insert_mode()
245			scrolled = i\
246			- self.nvimtk.current_rows\
247			+ STATUS_BAR_HEIGHT
248			self.send_tk_key(*str(i-1))
249			self.send_tk_key('Enter')
250
251			# Make sure our last jump covers an entire page
252			last_scroll = old_scroll = self.nvimtk.max_scroll
253			if last_scroll < self.nvimtk.current_rows:
254			last_scroll = self.nvimtk.current_rows + 1
255			self.nvimtk.max_scroll = last_scroll
256
257			if scrolled in (1, 2, last_scroll):
258			to_top = self.nvimtk.current_rows + scrolled
259			time.sleep(1)
260			_do(to_top)
261			if scrolled == last_scroll:
262			self.nvimtk.max_scroll = old_scroll
263			break
264
265
266			def test_big_file(self):
267			'''
268			doesn't test anything that our other tests doesn't,
269			but just paves the way for testing a file
270			'''
271			test_file = os.path.join(os.path.dirname(__file__),
272			'test_file')
273			self.v_normal_mode()
274			self.send_tk_key(*':e! '+test_file)
275			self.send_tk_key('Enter')
276			# Give time for actions to take place
277			time.sleep(1)
278			self.compare_screens()
279			# TODO READ LEN OF FILE
280			old_max = self.nvimtk.max_scroll
281			self.nvimtk.max_scroll = 500
282			self.v_page_down()
283			time.sleep(0.5)
284			self.compare_screens()
285			self.v_page_up()
286			time.sleep(0.5)
287			self.compare_screens()
288			self.nvimtk.max_sroll = old_max
289			self.nvim.command('bwipeout')
290
291
292			def test_number(self):
293			to_test = ('load', 'basic_insert', 'enter_key')
294			self.nvim.command("set nonumber")
295			self.nvim.command("set relativenumber")
296			time.sleep(0.5)
297			for test in to_test:
298			method = getattr(self, 'test_' + test)
299			method()
300			self.teardown_method(method)
301

timeyyy / pytknvim

Push — master ( e78923...5c165f )

TestIntegration.test_big_file() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like