Refactor testing infrastructure, migrate to use fixtures

tests/conftest.py

@@ -0,0 +1,131 @@
+import pytest
+
+import py_cui
+import py_cui.debug as dbg
+import py_cui.grid
+
+
+
+@pytest.fixture
+def LOGGER():
+    return dbg.PyCUILogger('PYCUI TEST')
+
+
+@pytest.fixture
+def RENDERER(request, LOGGER):
+    return py_cui.renderer.Renderer(None, None, LOGGER)
+
+
+@pytest.fixture
+def GRID(request, LOGGER):
+
+    def _GRID(rows, cols, height, width):
+
+        return py_cui.grid.Grid(rows, cols, height, width, LOGGER)
+
+    return _GRID
+
+
+@pytest.fixture
+def DUMMYWIDGET(request, GRID, LOGGER):
+
+    dummy_grid = GRID(3, 3, 30, 30)
+    return py_cui.widgets.Widget('1', 'Test', dummy_grid, 1, 1, 1, 1, 1, 0, LOGGER)
+
+
+@pytest.fixture
+def CUSTOMWIDGET(request, GRID, LOGGER):
+
+    def _CUSTOMWIDGET(id, name, row, col, rowspan, colspan):
+        test_grid = GRID(5, 7, 90, 210)
+        return py_cui.widgets.Widget(id, name, test_grid, row, col, rowspan, colspan, 1, 0, LOGGER)
+
+    return _CUSTOMWIDGET
+
+
+@pytest.fixture
+def PYCUI():
+
+    def _PYCUI(rows, cols, height, width):
+        return py_cui.PyCUI(rows, cols, simulated_terminal=[height, width])
+
+    return _PYCUI
+
+
+@pytest.fixture
+def WIDGETSET(request, LOGGER):
+
+    def _WIDGETSET(rows, cols, height, width):
+        return py_cui.widget_set.WidgetSet(rows, cols, LOGGER, simulated_terminal=[height, width])
+
+    return _WIDGETSET
+
+
+@pytest.fixture
+def SCROLLMENU(request, GRID, LOGGER):
+
+    test_grid = GRID(10, 10, 100, 100)
+    scroll = py_cui.widgets.ScrollMenu('1', 'Scroll', test_grid, 0, 0, 1, 1, 1, 0, LOGGER)
+    scroll.selected = True
+
+    return scroll
+
+
+@pytest.fixture
+def CHECKBOXMENU(request, GRID, LOGGER):
+
+    test_grid = GRID(10, 10, 100, 100)
+    scroll = py_cui.widgets.CheckBoxMenu('1', 'Scroll', test_grid, 0, 0, 1, 1, 1, 0, LOGGER, 'X')
+    scroll.selected = True
+
+    return scroll
+
+
+@pytest.fixture
+def TEXTBOX(request, GRID, LOGGER):
+
+    def _TEXTBOX(text='Hello World', row=1, col=1, rowspan=1, colspan=2):
+        test_grid = GRID(10,10,100,100)
+        text_box = py_cui.widgets.TextBox('id', 'Test', test_grid,
+                                            row, col, rowspan, colspan, 1, 0, LOGGER,
+                                            text, False)
+        return text_box
+
+    return _TEXTBOX
+
+
+@pytest.fixture
+def SCROLLTEXTBLOCK(request, GRID, LOGGER):
+
+    def _SCROLLTEXTBLOCK(text, row=1, col=1, row_span=1, col_span=2):
+
+        test_grid = GRID(3, 3, 120, 120)
+        text_box = py_cui.widgets.ScrollTextBlock('id', 'Test', test_grid,
+                                                    row, col, row_span, col_span, 1, 0,
+                                                    LOGGER, text)
+        return text_box
+
+    return _SCROLLTEXTBLOCK
+
+
+@pytest.fixture
+def SLIDER(request, GRID, LOGGER):
+
+    def _SLIDER(minval=10, maxval=90, step=4, init_val=30):
+        test_grid = GRID(10, 10, 100, 100)
+        slider = py_cui.control_widgets.slider.SliderWidget('id', 'slider', test_grid, 1, 1, 1, 2,
+                                                            1, 0, LOGGER, minval, maxval, step, init_val)
+        return slider
+
+    return _SLIDER
+
+
+@pytest.fixture
+def COLORRULE(request, LOGGER):
+
+    def _COLORRULE(text, rule_type, match_type, color_A=py_cui.RED_ON_BLACK, color_B=py_cui.RED_ON_BLACK, region=None, whitespace=False):
+
+        color_rule = py_cui.colors.ColorRule(text, color_A, color_B, rule_type, match_type, region, whitespace, LOGGER)
+        return color_rule
+
+    return _COLORRULE

tests/test_colors.py → tests/test_core/test_colors.py

@@ -1,60 +1,49 @@
 import pytest # noqa
 import py_cui
-from py_cui.colors import ColorRule
-import py_cui.debug as dbg
-
-# Initialize debug logger
-logger = dbg.PyCUILogger('PYCUI TEST')
 
 # Some test strings
 test_string_A = "Hello world, etc 123 @ testing @ ++-- Test"
 test_string_B = "     Test string number two Space"
 test_string_C = "Hi"
 
-# Initialize a dummy grid, widget, and color rules
-dummy_grid = py_cui.grid.Grid(3, 3, 30, 30, logger)
-dummy_widget = py_cui.widgets.Widget('1', 'Test', dummy_grid,
-                                     1, 1, 1, 1, 1, 0, logger)
-
-color_rule_A = ColorRule('@.*@', py_cui.RED_ON_BLACK, py_cui.RED_ON_BLACK,
-                         'contains', 'regex', None, False, logger)
-
-color_rule_B = ColorRule('Test', py_cui.RED_ON_BLACK, py_cui.RED_ON_BLACK,
-                         'startswith', 'line', None, False, logger)
-
-color_rule_C = ColorRule('Space', py_cui.RED_ON_BLACK, py_cui.RED_ON_BLACK,
-                         'endswith', 'regex', None,   False, logger)
 
-color_rule_D = ColorRule('Test', py_cui.RED_ON_BLACK, py_cui.RED_ON_BLACK,
-                         'notstartswith', 'region', [3, 5], False, logger)
+def gen_color_rule_examples(rule_gen):
+    color_rule_examples = []
+    color_rule_examples.append(rule_gen('@.*@', 'contains', 'regex'))
+    color_rule_examples.append(rule_gen('Test', 'startswith', 'line'))
+    color_rule_examples.append(rule_gen('Space', 'endswith', 'regex'))
+    color_rule_examples.append(rule_gen('Test', 'notstartswith', 'region', region=[3,5]))
+    color_rule_examples.append(rule_gen('Test', 'notendswith', 'line'))
 
-color_rule_E = ColorRule('Test', py_cui.RED_ON_BLACK, py_cui.RED_ON_BLACK,
-                         'notendswith', 'line', None, False, logger)
+    return color_rule_examples
 
 
-def test_check_match():
-    assert color_rule_A._check_match(test_string_A) is True
-    assert color_rule_B._check_match(test_string_A) is False
-    assert color_rule_C._check_match(test_string_A) is False
-    assert color_rule_D._check_match(test_string_A) is True
-    assert color_rule_E._check_match(test_string_A) is False
+def test_check_match(COLORRULE):
+    rules = gen_color_rule_examples(COLORRULE)
+
+    assert rules[0]._check_match(test_string_A) is True
+    assert rules[1]._check_match(test_string_A) is False
+    assert rules[2]._check_match(test_string_A) is False
+    assert rules[3]._check_match(test_string_A) is True
+    assert rules[4]._check_match(test_string_A) is False
 
-    assert color_rule_A._check_match(test_string_B) is False
-    assert color_rule_B._check_match(test_string_B) is True
-    assert color_rule_C._check_match(test_string_B) is True
-    assert color_rule_D._check_match(test_string_B) is False
-    assert color_rule_E._check_match(test_string_B) is True
+    assert rules[0]._check_match(test_string_B) is False
+    assert rules[1]._check_match(test_string_B) is True
+    assert rules[2]._check_match(test_string_B) is True
+    assert rules[3]._check_match(test_string_B) is False
+    assert rules[4]._check_match(test_string_B) is True
 
-    assert color_rule_A._check_match(test_string_C) is False
-    assert color_rule_B._check_match(test_string_C) is False
-    assert color_rule_C._check_match(test_string_C) is False
-    assert color_rule_D._check_match(test_string_C) is True
-    assert color_rule_E._check_match(test_string_C) is True
+    assert rules[0]._check_match(test_string_C) is False
+    assert rules[1]._check_match(test_string_C) is False
+    assert rules[2]._check_match(test_string_C) is False
+    assert rules[3]._check_match(test_string_C) is True
+    assert rules[4]._check_match(test_string_C) is True
 
 
-def test_generate_fragments_A():
+def test_generate_fragments_contains_regex(COLORRULE, DUMMYWIDGET):
+    rules = gen_color_rule_examples(COLORRULE)
 
-    fragments, match = color_rule_A.generate_fragments(dummy_widget,
+    fragments, match = rules[0].generate_fragments(DUMMYWIDGET,
                                                        test_string_A,
                                                        test_string_A)
     assert match is True
@@ -66,15 +55,15 @@ def test_generate_fragments_A():
     assert fragments[2][0] == " ++-- Test"
     assert fragments[2][1] == py_cui.WHITE_ON_BLACK
 
-    fragments, match = color_rule_A.generate_fragments(dummy_widget,
+    fragments, match = rules[0].generate_fragments(DUMMYWIDGET,
                                                        test_string_B,
                                                        test_string_B)
     assert match is False
     assert len(fragments) == 1
     assert fragments[0][0] == test_string_B
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
-    fragments, match = color_rule_A.generate_fragments(dummy_widget,
+    fragments, match = rules[0].generate_fragments(DUMMYWIDGET,
                                                        test_string_C,
                                                        test_string_C)
     assert match is False
@@ -83,25 +72,26 @@ def test_generate_fragments_A():
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
 
-def test_generate_fragments_B():
+def test_generate_fragments_startswith_line(COLORRULE, DUMMYWIDGET):
+    rules = gen_color_rule_examples(COLORRULE)
 
-    fragments, match = color_rule_B.generate_fragments(dummy_widget,
+    fragments, match = rules[1].generate_fragments(DUMMYWIDGET,
                                                        test_string_A,
                                                        test_string_A)
     assert match is False
     assert len(fragments) == 1
     assert fragments[0][0] == test_string_A
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
-    fragments, match = color_rule_B.generate_fragments(dummy_widget,
+    fragments, match = rules[1].generate_fragments(DUMMYWIDGET,
                                                        test_string_B,
                                                        test_string_B)
     assert match is True
     assert len(fragments) == 1
     assert fragments[0][0] == test_string_B
     assert fragments[0][1] == py_cui.RED_ON_BLACK
 
-    fragments, match = color_rule_B.generate_fragments(dummy_widget,
+    fragments, match = rules[1].generate_fragments(DUMMYWIDGET,
                                                        test_string_C,
                                                        test_string_C)
     assert match is False
@@ -110,16 +100,18 @@ def test_generate_fragments_B():
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
 
-def test_generate_fragments_C():
-    fragments, match = color_rule_C.generate_fragments(dummy_widget,
+def test_generate_fragments_endswith_regex(COLORRULE, DUMMYWIDGET):
+    rules = gen_color_rule_examples(COLORRULE)
+
+    fragments, match = rules[2].generate_fragments(DUMMYWIDGET,
                                                        test_string_A,
                                                        test_string_A)
     assert match is False
     assert len(fragments) == 1
     assert fragments[0][0] == test_string_A
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
-    fragments, match = color_rule_C.generate_fragments(dummy_widget,
+    fragments, match = rules[2].generate_fragments(DUMMYWIDGET,
                                                        test_string_B,
                                                        test_string_B)
     assert match is True
@@ -131,7 +123,7 @@ def test_generate_fragments_C():
     assert fragments[2][0] == ''
     assert fragments[2][1] == py_cui.WHITE_ON_BLACK
 
-    fragments, match = color_rule_C.generate_fragments(dummy_widget,
+    fragments, match = rules[2].generate_fragments(DUMMYWIDGET,
                                                        test_string_C,
                                                        test_string_C)
     assert match is False
@@ -140,8 +132,10 @@ def test_generate_fragments_C():
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
 
-def test_generate_fragments_D():
-    fragments, match = color_rule_D.generate_fragments(dummy_widget,
+def test_generate_fragments_notstartswith_region(COLORRULE, DUMMYWIDGET):
+    rules = gen_color_rule_examples(COLORRULE)
+
+    fragments, match = rules[3].generate_fragments(DUMMYWIDGET,
                                                        test_string_A,
                                                        test_string_A)
     assert match is True
@@ -153,15 +147,15 @@ def test_generate_fragments_D():
     assert fragments[2][0] == " world, etc 123 @ testing @ ++-- Test"
     assert fragments[2][1] == py_cui.WHITE_ON_BLACK
 
-    fragments, match = color_rule_D.generate_fragments(dummy_widget,
+    fragments, match = rules[3].generate_fragments(DUMMYWIDGET,
                                                        test_string_B,
                                                        test_string_B)
     assert match is False
     assert len(fragments) == 1
     assert fragments[0][0] == test_string_B
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
-    fragments, match = color_rule_D.generate_fragments(dummy_widget,
+    fragments, match = rules[3].generate_fragments(DUMMYWIDGET,
                                                        test_string_C,
                                                        test_string_C)
     # In this case we match, but our input is too small
@@ -172,24 +166,26 @@ def test_generate_fragments_D():
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
 
-def test_generate_fragments_E():
-    fragments, match = color_rule_E.generate_fragments(dummy_widget,
+def test_generate_fragments_notendswith_line(COLORRULE, DUMMYWIDGET):
+    rules = gen_color_rule_examples(COLORRULE)
+
+    fragments, match = rules[4].generate_fragments(DUMMYWIDGET,
                                                        test_string_A,
                                                        test_string_A)
     assert match is False
     assert len(fragments) == 1
     assert fragments[0][0] == test_string_A
     assert fragments[0][1] == py_cui.WHITE_ON_BLACK
 
-    fragments, match = color_rule_E.generate_fragments(dummy_widget,
+    fragments, match = rules[4].generate_fragments(DUMMYWIDGET,
                                                        test_string_B,
                                                        test_string_B)
     assert len(fragments) == 1
     assert match is True
     assert fragments[0][0] == test_string_B
     assert fragments[0][1] == py_cui.RED_ON_BLACK
 
-    fragments, match = color_rule_E.generate_fragments(dummy_widget,
+    fragments, match = rules[4].generate_fragments(DUMMYWIDGET,
                                                        test_string_C,
                                                        test_string_C)
     assert match is True