Submenu code fully extracted and all tests pass

Author: kotfu

setup.py

@@ -1,5 +1,5 @@
 #
-# -*- coding: utf-8 -*-
+# coding=utf-8
 
 import os
 import setuptools

tests/conftest.py

@@ -0,0 +1,35 @@
+#
+# coding=utf-8
+
+class StdOut(object):
+    """ Toy class for replacing self.stdout in cmd2.Cmd instances for unit testing. """
+    def __init__(self):
+        self.buffer = ''
+
+    def write(self, s):
+        self.buffer += s
+
+    def read(self):
+        raise NotImplementedError
+
+    def clear(self):
+        self.buffer = ''
+
+def normalize(block):
+    """ Normalize a block of text to perform comparison.
+
+    Strip newlines from the very beginning and very end  Then split into separate lines and strip trailing whitespace
+    from each line.
+    """
+    assert isinstance(block, str)
+    block = block.strip('\n')
+    return [line.rstrip() for line in block.splitlines()]
+
+
+def run_cmd(app, cmd):
+    """ Clear StdOut buffer, run the command, extract the buffer contents, """
+    app.stdout.clear()
+    app.onecmd_plus_hooks(cmd)
+    out = app.stdout.buffer
+    app.stdout.clear()
+    return normalize(out)

tests/test_submenu.py

@@ -1,19 +1,23 @@
+#
 # coding=utf-8
 """
 Cmd2 testing for argument parsing
 """
+import readline
+
 import pytest
+from unittest import mock
 
 from cmd2 import cmd2
 import cmd2_submenu
-from .conftest import run_cmd, StdOut, normalize
+from conftest import run_cmd, StdOut, normalize
 
 
 class SecondLevelB(cmd2.Cmd):
     """To be used as a second level command class. """
 
     def __init__(self, *args, **kwargs):
-        super().__init__(self, *args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.prompt = '2ndLevel B '
 
     def do_get_top_level_attr(self, line):
@@ -27,7 +31,7 @@ class SecondLevel(cmd2.Cmd):
     """To be used as a second level command class. """
 
     def __init__(self, *args, **kwargs):
-        super().__init__(self, *args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.prompt = '2ndLevel '
         self.top_level_attr = None
 
@@ -67,7 +71,7 @@ class SubmenuApp(cmd2.Cmd):
     """To be used as the main / top level command class that will contain other submenus."""
 
     def __init__(self, *args, **kwargs):
-        super().__init__(self, *args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.prompt = 'TopLevel '
         self.top_level_attr = 123456789
 
@@ -103,7 +107,6 @@ def secondlevel_app_b():
     app.stdout = StdOut()
     return app
 
-
 def run_submenu_cmd(app, second_level_app, cmd):
     """ Clear StdOut buffers, run the command, extract the buffer contents."""
     app.stdout.clear()
@@ -115,15 +118,52 @@ def run_submenu_cmd(app, second_level_app, cmd):
     second_level_app.stdout.clear()
     return normalize(out1), normalize(out2)
 
+def complete_tester(text, line, begidx, endidx, app):
+    """
+    This is a convenience function to test cmd2.complete() since
+    in a unit test environment there is no actual console readline
+    is monitoring. Therefore we use mock to provide readline data
+    to complete().
+
+    :param text: str - the string prefix we are attempting to match
+    :param line: str - the current input line with leading whitespace removed
+    :param begidx: int - the beginning index of the prefix text
+    :param endidx: int - the ending index of the prefix text
+    :param app: the cmd2 app that will run completions
+    :return: The first matched string or None if there are no matches
+             Matches are stored in app.completion_matches
+             These matches also have been sorted by complete()
+    """
+    def get_line():
+        return line
+
+    def get_begidx():
+        return begidx
+
+    def get_endidx():
+        return endidx
+
+    first_match = None
+    with mock.patch.object(readline, 'get_line_buffer', get_line):
+        with mock.patch.object(readline, 'get_begidx', get_begidx):
+            with mock.patch.object(readline, 'get_endidx', get_endidx):
+                # Run the readline tab-completion function with readline mocks in place
+                first_match = app.complete(text, 0)
+
+    return first_match
 
+######
+#
+# test submenu functionality
+#
+######
 def test_submenu_say_from_top_level(submenu_app):
     line = 'testing'
     out1, out2 = run_submenu_cmd(submenu_app, second_level_cmd, 'say ' + line)
     assert len(out1) == 1
     assert len(out2) == 0
     assert out1[0] == "You called a command in TopLevel with {!r}.".format(line)
 
-
 def test_submenu_second_say_from_top_level(submenu_app):
     line = 'testing'
     out1, out2 = run_submenu_cmd(submenu_app, second_level_cmd, 'second say ' + line)
@@ -135,13 +175,11 @@ def test_submenu_second_say_from_top_level(submenu_app):
     assert len(out2) == 1
     assert out2[0] == "You called a command in SecondLevel with {!r}.".format(line)
 
-
 def test_submenu_say_from_second_level(secondlevel_app):
     line = 'testing'
     out = run_cmd(secondlevel_app, 'say ' + line)
     assert out == ["You called a command in SecondLevel with '%s'." % line]
 
-
 def test_submenu_help_second_say_from_top_level(submenu_app):
     out1, out2 = run_submenu_cmd(submenu_app, second_level_cmd, 'help second say')
     # No output expected from the top level
@@ -150,29 +188,24 @@ def test_submenu_help_second_say_from_top_level(submenu_app):
     # Output expected from the second level
     assert out2 == ["This is a second level menu. Options are qwe, asd, zxc"]
 
-
 def test_submenu_help_say_from_second_level(secondlevel_app):
     out = run_cmd(secondlevel_app, 'help say')
     assert out == ["This is a second level menu. Options are qwe, asd, zxc"]
 
-
 def test_submenu_help_second(submenu_app):
     out1, out2 = run_submenu_cmd(submenu_app, second_level_cmd, 'help second')
     out3 = run_cmd(second_level_cmd, 'help')
     assert out2 == out3
 
-
 def test_submenu_from_top_help_second_say(submenu_app):
     out1, out2 = run_submenu_cmd(submenu_app, second_level_cmd, 'help second say')
     out3 = run_cmd(second_level_cmd, 'help say')
     assert out2 == out3
 
-
 def test_submenu_shared_attribute(submenu_app):
     out1, out2 = run_submenu_cmd(submenu_app, second_level_cmd, 'second get_top_level_attr')
     assert out2 == [str(submenu_app.top_level_attr)]
 
-
 def test_submenu_shared_attribute_preserve(submenu_app):
     out1, out2 = run_submenu_cmd(submenu_app, second_level_b_cmd, 'secondb get_top_level_attr')
     assert out2 == [str(submenu_app.top_level_attr)]
@@ -184,127 +217,80 @@ def test_submenu_shared_attribute_preserve(submenu_app):
 
 ######
 #
-# from test_completion.py
+# test completion in submenus
 #
 ######
 
-####################################################
-
-
-class SecondLevel(cmd2.Cmd):
-    """To be used as a second level command class. """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(self, *args, **kwargs)
-        self.prompt = '2ndLevel '
-
-    def do_foo(self, line):
-        self.poutput("You called a command in SecondLevel with '%s'. " % line)
-
-    def help_foo(self):
-        self.poutput("This is a second level menu. Options are qwe, asd, zxc")
-
-    def complete_foo(self, text, line, begidx, endidx):
-        return [s for s in ['qwe', 'asd', 'zxc'] if s.startswith(text)]
-
-
-second_level_cmd = SecondLevel()
-
-
-@cmd2_submenu.AddSubmenu(second_level_cmd,
-                 command='second',
-                 require_predefined_shares=False)
-class SubmenuApp(cmd2.Cmd):
-    """To be used as the main / top level command class that will contain other submenus."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(self, *args, **kwargs)
-        self.prompt = 'TopLevel '
-
-
-@pytest.fixture
-def sb_app():
-    app = SubmenuApp()
-    return app
-
-
-def test_cmd2_submenu_completion_single_end(sb_app):
-    text = 'f'
+def test_cmd2_submenu_completion_single_end(submenu_app):
+    text = 'sa'
     line = 'second {}'.format(text)
     endidx = len(line)
     begidx = endidx - len(text)
 
-    first_match = complete_tester(text, line, begidx, endidx, sb_app)
+    first_match = complete_tester(text, line, begidx, endidx, submenu_app)
 
     # It is at end of line, so extra space is present
-    assert first_match is not None and sb_app.completion_matches == ['foo ']
-
+    assert first_match is not None and submenu_app.completion_matches == ['say ']
 
-def test_cmd2_submenu_completion_multiple(sb_app):
+def test_cmd2_submenu_completion_multiple(submenu_app):
     text = 'e'
     line = 'second {}'.format(text)
     endidx = len(line)
     begidx = endidx - len(text)
 
     expected = ['edit', 'eof', 'eos']
-    first_match = complete_tester(text, line, begidx, endidx, sb_app)
+    first_match = complete_tester(text, line, begidx, endidx, submenu_app)
 
-    assert first_match is not None and sb_app.completion_matches == expected
+    assert first_match is not None and submenu_app.completion_matches == expected
 
-
-def test_cmd2_submenu_completion_nomatch(sb_app):
+def test_cmd2_submenu_completion_nomatch(submenu_app):
     text = 'z'
     line = 'second {}'.format(text)
     endidx = len(line)
     begidx = endidx - len(text)
 
-    first_match = complete_tester(text, line, begidx, endidx, sb_app)
+    first_match = complete_tester(text, line, begidx, endidx, submenu_app)
     assert first_match is None
 
-
-def test_cmd2_submenu_completion_after_submenu_match(sb_app):
+def test_cmd2_submenu_completion_after_submenu_match(submenu_app):
     text = 'a'
-    line = 'second foo {}'.format(text)
+    line = 'second say {}'.format(text)
     endidx = len(line)
     begidx = endidx - len(text)
 
-    first_match = complete_tester(text, line, begidx, endidx, sb_app)
-    assert first_match is not None and sb_app.completion_matches == ['asd ']
-
+    first_match = complete_tester(text, line, begidx, endidx, submenu_app)
+    assert first_match is not None and submenu_app.completion_matches == ['asd ']
 
-def test_cmd2_submenu_completion_after_submenu_nomatch(sb_app):
+def test_cmd2_submenu_completion_after_submenu_nomatch(submenu_app):
     text = 'b'
-    line = 'second foo {}'.format(text)
+    line = 'second say {}'.format(text)
     endidx = len(line)
     begidx = endidx - len(text)
 
-    first_match = complete_tester(text, line, begidx, endidx, sb_app)
+    first_match = complete_tester(text, line, begidx, endidx, submenu_app)
     assert first_match is None
 
-
-def test_cmd2_help_submenu_completion_multiple(sb_app):
+def test_cmd2_help_submenu_completion_multiple(submenu_app):
     text = 'p'
     line = 'help second {}'.format(text)
     endidx = len(line)
     begidx = endidx - len(text)
 
-    matches = sorted(sb_app.complete_help(text, line, begidx, endidx))
+    matches = sorted(submenu_app.complete_help(text, line, begidx, endidx))
     assert matches == ['py', 'pyscript']
 
-
-def test_cmd2_help_submenu_completion_nomatch(sb_app):
+def test_cmd2_help_submenu_completion_nomatch(submenu_app):
     text = 'fake'
     line = 'help second {}'.format(text)
     endidx = len(line)
     begidx = endidx - len(text)
-    assert sb_app.complete_help(text, line, begidx, endidx) == []
-
+    assert submenu_app.complete_help(text, line, begidx, endidx) == []
 
-def test_cmd2_help_submenu_completion_subcommands(sb_app):
+def test_cmd2_help_submenu_completion_subcommands(submenu_app):
     text = 'p'
     line = 'help second {}'.format(text)
     endidx = len(line)
     begidx = endidx - len(text)
 
-    matches = sorted(sb_app.complete_help(text, line, begidx, endidx))
+    matches = sorted(submenu_app.complete_help(text, line, begidx, endidx))
     assert matches == ['py', 'pyscript']