Merge pull request #42 from paiweilai/improve-test-coverage

Improve test coverage

tests/cmd/logic_test.py

@@ -3,12 +3,18 @@
 from __future__ import division
 from __future__ import print_function
 
+from undebt.cmd.logic import _fix_pattern
 from undebt.cmd.logic import process
 from undebt.examples import attribute_to_function
 from undebt.examples import method_to_function
 from undebt.pattern.interface import get_patterns
 
 
+def test_fix_pattern_is_tuple():
+    pattern = ('fake_tuple_pattern',)
+    assert _fix_pattern(pattern) == [pattern]
+
+
 def test_no_match():
     patterns = get_patterns(attribute_to_function)
     text = """

tests/pattern/interface_test.py

@@ -3,16 +3,32 @@
 from __future__ import division
 from __future__ import print_function
 
-from undebt.examples import attribute_to_function
-from undebt.pattern.interface import get_patterns
-from undebt.pattern.python import HEADER
-
-
-def test_get_patterns():
-    # patterns = [[(grammar, replace), (HEADER, extra_replace)]]
-    patterns = get_patterns(attribute_to_function)
-    [patternset] = patterns
-    [pattern1, pattern2] = patternset
-    (grammar1, replace1) = pattern1
-    (grammar2, replace2) = pattern2
-    assert grammar2 is HEADER
+import mock
+
+from undebt.pattern.interface import _get_patterns
+
+
+def test_get_patterns_module_with_patterns():
+    fake_pattern = mock.MagicMock()
+    assert _get_patterns(fake_pattern) == fake_pattern.patterns
+
+
+def test_get_patterns_module_with_grammar_and_replace():
+    fake_pattern = mock.MagicMock()
+    del fake_pattern.patterns
+    del fake_pattern.extra
+    assert _get_patterns(fake_pattern) == [(fake_pattern.grammar, fake_pattern.replace)]
+
+
+@mock.patch('undebt.pattern.interface.log.error')
+@mock.patch('undebt.pattern.interface.sys.exit')
+def test_get_patterns_module_bad_format(mock_exit, mock_log):
+    fake_pattern = mock.MagicMock()
+    fake_pattern.__name__ = 'fake_pattern'
+    del fake_pattern.patterns
+    del fake_pattern.grammar
+
+    _get_patterns(fake_pattern)
+
+    assert mock_log.call_count == 1
+    mock_exit.assert_called_once_with(1)

tests/pattern/util_test.py

@@ -3,13 +3,40 @@
 from __future__ import division
 from __future__ import print_function
 
+import sys
+
+import mock
+from pyparsing import Keyword
+
 from undebt.pattern.testing import assert_parse
+from undebt.pattern.util import debug
 from undebt.pattern.util import in_string
 from undebt.pattern.util import leading_whitespace
 from undebt.pattern.util import quoted
 from undebt.pattern.util import trailing_whitespace
 
 
+if sys.version_info.major == 3:
+    builtin_module_name = 'builtins'
+else:
+    builtin_module_name = '__builtin__'
+
+
+@mock.patch('{}.print'.format(builtin_module_name))
+def test_debug(mock_print):
+    assert_parse(
+        grammar=debug(Keyword('something')),
+        text="something",
+        tokens_list=[
+            [mock_print.return_value],
+        ],
+        interval_list=[
+            (0, 9)
+        ],
+    )
+    assert mock_print.call_count == 1
+
+
 def test_quoted():
     assert_parse(
         grammar=quoted("derp"),

undebt/cmd/logic.py

@@ -11,14 +11,11 @@
 def process(patterns, text):
     """Return text modified by patterns."""
 
-    for i in range(len(patterns)):
-        if isinstance(patterns[i], tuple):
-            inner_patterns = [patterns[i]]
-        else:
-            inner_patterns = patterns[i]
+    for i, p in enumerate(patterns):
+        pattern = _fix_pattern(p)
 
         found = []
-        for grammar, replace in inner_patterns:
+        for grammar, replace in pattern:
 
             find_and_replace = create_find_and_replace(grammar, replace)
             results = parse_grammar(find_and_replace, text)
@@ -38,6 +35,13 @@ def process(patterns, text):
     return text
 
 
+def _fix_pattern(pattern):
+    if isinstance(pattern, tuple):
+        return [pattern]
+    else:
+        return pattern
+
+
 def _transform_results(results, text):
     new_strings = []
     intervals = []

undebt/pattern/interface.py

@@ -33,28 +33,24 @@ def _fix_index(index):
 
 def get_patterns(*pattern_modules):
     """Returns patterns for pattern modules."""
-    pattern_list = []
-    for pattern in pattern_modules:
+    return [_get_patterns(p) for p in pattern_modules]
 
-        # new style pattern files
-        if hasattr(pattern, "patterns"):
-            patterns = pattern.patterns
 
-        # old style pattern files
-        elif hasattr(pattern, "grammar") and hasattr(pattern, "replace"):
-            patterns = [(pattern.grammar, pattern.replace)]
-            if hasattr(pattern, "extra"):
-                patterns.append(get_pattern_for_extra(pattern.extra))
+def _get_patterns(pattern):
+    if hasattr(pattern, "patterns"):
+        return pattern.patterns
 
-        else:
-            log.error(
-                'pattern file {} must define either ("patterns") or ("grammar" and "replace" and optionally "extra")'
-                .format(pattern.__name__)
-            )
-            sys.exit(1)
-
-        pattern_list.append(patterns)
-    return pattern_list
+    if hasattr(pattern, "grammar") and hasattr(pattern, "replace"):
+        patterns = [(pattern.grammar, pattern.replace)]
+        if hasattr(pattern, "extra"):
+            patterns.append(get_pattern_for_extra(pattern.extra))
+        return patterns
+
+    log.error(
+        'pattern file {} must define either ("patterns") or ("grammar" and "replace" and optionally "extra")'
+        .format(pattern.__name__)
+    )
+    sys.exit(1)
 
 
 def get_pattern_for_extra(extra):