cmd2 3.1.2__tar.gz → 3.1.3__tar.gz

{cmd2-3.1.2 → cmd2-3.1.3}/.pre-commit-config.yaml

@@ -9,7 +9,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.14.14"
+    rev: "v0.15.0"
     hooks:
       - id: ruff-format
         args: [--config=ruff.toml]
@@ -21,5 +21,5 @@ repos:
     hooks:
       - id: prettier
         additional_dependencies:
-          - prettier@3.8.0
+          - prettier@3.8.1
           - prettier-plugin-toml@2.0.6

{cmd2-3.1.2 → cmd2-3.1.3}/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 3.1.3 (February 3, 2026)
+
+- Bug Fixes
+    - Fixed issue where `delimiter_complete()` could cause more matches than display matches
+    - Fixed issue where `CommandSet` registration did not respect disabled categories
+
 ## 3.1.2 (January 26, 2026)
 
 - Bug Fixes

{cmd2-3.1.2 → cmd2-3.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 3.1.2
+Version: 3.1.3
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT

{cmd2-3.1.2 → cmd2-3.1.3}/cmd2/argparse_completer.py

@@ -539,7 +539,7 @@ class ArgparseCompleter:
         # Check if there are too many CompletionItems to display as a table
         if len(completions) <= self._cmd2_app.max_completion_items:
             # If a metavar was defined, use that instead of the dest field
-            destination = arg_state.action.metavar if arg_state.action.metavar else arg_state.action.dest
+            destination = arg_state.action.metavar or arg_state.action.dest
 
             # Handle case where metavar was a tuple
             if isinstance(destination, tuple):
@@ -587,7 +587,7 @@ class ArgparseCompleter:
             # Generate the hint table string
             console = Cmd2GeneralConsole()
             with console.capture() as capture:
-                console.print(hint_table, end="")
+                console.print(hint_table, end="", soft_wrap=False)
             self._cmd2_app.formatted_completions = capture.get()
 
         # Return sorted list of completions

{cmd2-3.1.2 → cmd2-3.1.3}/cmd2/argparse_custom.py

@@ -1477,7 +1477,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
             usage=usage,
             description=description,  # type: ignore[arg-type]
             epilog=epilog,  # type: ignore[arg-type]
-            parents=parents if parents else [],
+            parents=parents or [],
             formatter_class=formatter_class,
             prefix_chars=prefix_chars,
             fromfile_prefix_chars=fromfile_prefix_chars,

{cmd2-3.1.2 → cmd2-3.1.3}/cmd2/cmd2.py

@@ -593,11 +593,14 @@ class Cmd:
         # being printed by a command.
         self.terminal_lock = threading.RLock()
 
-        # Commands that have been disabled from use. This is to support commands that are only available
-        # during specific states of the application. This dictionary's keys are the command names and its
-        # values are DisabledCommand objects.
+        # Commands disabled during specific application states
+        # Key: Command name | Value: DisabledCommand object
         self.disabled_commands: dict[str, DisabledCommand] = {}
 
+        # Categories of commands to be disabled
+        # Key: Category name | Value: Message to display
+        self.disabled_categories: dict[str, str] = {}
+
         # The default key for sorting string results. Its default value performs a case-insensitive alphabetical sort.
         # If natural sorting is preferred, then set this to NATURAL_SORT_KEY.
         # cmd2 uses this key for sorting:
@@ -755,9 +758,11 @@ class Cmd:
             list[tuple[str, Callable[..., Any]]],
             inspect.getmembers(
                 cmdset,
-                predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
-                and hasattr(meth, '__name__')
-                and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
+                predicate=lambda meth: (  # type: ignore[arg-type]
+                    isinstance(meth, Callable)  # type: ignore[arg-type]
+                    and hasattr(meth, '__name__')
+                    and meth.__name__.startswith(COMMAND_FUNC_PREFIX)
+                ),
             ),
         )
 
@@ -788,6 +793,12 @@ class Cmd:
                 if default_category and not hasattr(command_method, constants.CMD_ATTR_HELP_CATEGORY):
                     utils.categorize(command_method, default_category)
 
+                # If this command is in a disabled category, then disable it
+                command_category = getattr(command_method, constants.CMD_ATTR_HELP_CATEGORY, None)
+                if command_category in self.disabled_categories:
+                    message_to_print = self.disabled_categories[command_category]
+                    self.disable_command(command, message_to_print)
+
             self._installed_command_sets.add(cmdset)
 
             self._register_subcommands(cmdset)
@@ -904,9 +915,11 @@ class Cmd:
 
             methods: list[tuple[str, Callable[..., Any]]] = inspect.getmembers(
                 cmdset,
-                predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
-                and hasattr(meth, '__name__')
-                and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
+                predicate=lambda meth: (  # type: ignore[arg-type]
+                    isinstance(meth, Callable)  # type: ignore[arg-type]
+                    and hasattr(meth, '__name__')
+                    and meth.__name__.startswith(COMMAND_FUNC_PREFIX)
+                ),
             )
 
             for cmd_func_name, command_method in methods:
@@ -950,9 +963,11 @@ class Cmd:
 
         methods: list[tuple[str, Callable[..., Any]]] = inspect.getmembers(
             cmdset,
-            predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
-            and hasattr(meth, '__name__')
-            and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
+            predicate=lambda meth: (  # type: ignore[arg-type]
+                isinstance(meth, Callable)  # type: ignore[arg-type]
+                and hasattr(meth, '__name__')
+                and meth.__name__.startswith(COMMAND_FUNC_PREFIX)
+            ),
         )
 
         for cmd_func_name, command_method in methods:
@@ -974,10 +989,12 @@ class Cmd:
         # find methods that have the required attributes necessary to be recognized as a sub-command
         methods = inspect.getmembers(
             cmdset,
-            predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
-            and hasattr(meth, constants.SUBCMD_ATTR_NAME)
-            and hasattr(meth, constants.SUBCMD_ATTR_COMMAND)
-            and hasattr(meth, constants.CMD_ATTR_ARGPARSER),
+            predicate=lambda meth: (
+                isinstance(meth, Callable)  # type: ignore[arg-type]
+                and hasattr(meth, constants.SUBCMD_ATTR_NAME)
+                and hasattr(meth, constants.SUBCMD_ATTR_COMMAND)
+                and hasattr(meth, constants.CMD_ATTR_ARGPARSER)
+            ),
         )
 
         # iterate through all matching methods
@@ -1063,10 +1080,12 @@ class Cmd:
         # find methods that have the required attributes necessary to be recognized as a sub-command
         methods = inspect.getmembers(
             cmdset,
-            predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
-            and hasattr(meth, constants.SUBCMD_ATTR_NAME)
-            and hasattr(meth, constants.SUBCMD_ATTR_COMMAND)
-            and hasattr(meth, constants.CMD_ATTR_ARGPARSER),
+            predicate=lambda meth: (
+                isinstance(meth, Callable)  # type: ignore[arg-type]
+                and hasattr(meth, constants.SUBCMD_ATTR_NAME)
+                and hasattr(meth, constants.SUBCMD_ATTR_COMMAND)
+                and hasattr(meth, constants.CMD_ATTR_ARGPARSER)
+            ),
         )
 
         # iterate through all matching methods
@@ -1250,8 +1269,14 @@ class Cmd:
         :param sep: string to write between printed text. Defaults to " ".
         :param end: string to write at end of printed text. Defaults to a newline.
         :param style: optional style to apply to output
-        :param soft_wrap: Enable soft wrap mode. If True, lines of text will not be
-                          word-wrapped or cropped to fit the terminal width. Defaults to True.
+        :param soft_wrap: Enable soft wrap mode. Defaults to True.
+                          If True, text that doesn't fit will run on to the following line,
+                          just like with print(). This is useful for raw text and logs.
+                          If False, Rich wraps text to fit the terminal width.
+                          Set this to False when printing structured Renderables like
+                          Tables, Panels, or Columns to ensure they render as expected.
+                          For example, when soft_wrap is True Panels truncate text
+                          which is wider than the terminal.
         :param emoji: If True, Rich will replace emoji codes (e.g., :smiley:) with their
                       corresponding Unicode characters. Defaults to False.
         :param markup: If True, Rich will interpret strings with tags (e.g., [bold]hello[/bold])
@@ -1751,31 +1776,45 @@ class Cmd:
         :return: a list of possible tab completions
         """
         matches = self.basic_complete(text, line, begidx, endidx, match_against)
+        if not matches:
+            return []
 
-        # Display only the portion of the match that's being completed based on delimiter
-        if matches:
-            # Set this to True for proper quoting of matches with spaces
-            self.matches_delimited = True
+        # Set this to True for proper quoting of matches with spaces
+        self.matches_delimited = True
 
-            # Get the common beginning for the matches
-            common_prefix = os.path.commonprefix(matches)
-            prefix_tokens = common_prefix.split(delimiter)
+        # Get the common beginning for the matches
+        common_prefix = os.path.commonprefix(matches)
+        prefix_tokens = common_prefix.split(delimiter)
 
-            # Calculate what portion of the match we are completing
-            display_token_index = 0
-            if prefix_tokens:
-                display_token_index = len(prefix_tokens) - 1
+        # Calculate what portion of the match we are completing
+        display_token_index = 0
+        if prefix_tokens:
+            display_token_index = len(prefix_tokens) - 1
 
-            # Get this portion for each match and store them in self.display_matches
-            for cur_match in matches:
-                match_tokens = cur_match.split(delimiter)
-                display_token = match_tokens[display_token_index]
+        # Remove from each match everything after where the user is completing.
+        # This approach can result in duplicates so we will filter those out.
+        unique_results: dict[str, str] = {}
 
-                if not display_token:
-                    display_token = delimiter
-                self.display_matches.append(display_token)
+        for cur_match in matches:
+            match_tokens = cur_match.split(delimiter)
 
-        return matches
+            filtered_match = delimiter.join(match_tokens[: display_token_index + 1])
+            display_match = match_tokens[display_token_index]
+
+            # If there are more tokens, then we aren't done completing a full item
+            if len(match_tokens) > display_token_index + 1:
+                filtered_match += delimiter
+                display_match += delimiter
+                self.allow_appended_space = False
+                self.allow_closing_quote = False
+
+            if filtered_match not in unique_results:
+                unique_results[filtered_match] = display_match
+
+        filtered_matches = list(unique_results.keys())
+        self.display_matches = list(unique_results.values())
+
+        return filtered_matches
 
     def flag_based_complete(
         self,
@@ -2233,7 +2272,7 @@ class Cmd:
             # Otherwise use pyreadline3's formatter
             else:
                 # Check if we should show display_matches
-                matches_to_display = self.display_matches if self.display_matches else matches
+                matches_to_display = self.display_matches or matches
 
                 # Add padding for visual appeal
                 matches_to_display, _ = self._pad_matches_to_display(matches_to_display)
@@ -4236,7 +4275,7 @@ class Cmd:
             header_grid = Table.grid()
             header_grid.add_row(Text(header, style=Cmd2Style.HELP_HEADER))
             header_grid.add_row(Rule(characters=self.ruler, style=Cmd2Style.TABLE_BORDER))
-            self.poutput(header_grid)
+            self.poutput(header_grid, soft_wrap=False)
 
         # Subtract 1 from maxcol to account for a one-space right margin.
         maxcol = min(maxcol, ru.console_width()) - 1
@@ -4304,7 +4343,7 @@ class Cmd:
             topics_table.add_row(command, cmd_desc)
 
         category_grid.add_row(topics_table)
-        self.poutput(category_grid)
+        self.poutput(category_grid, soft_wrap=False)
         self.poutput()
 
     def render_columns(self, str_list: list[str] | None, display_width: int = 80) -> str:
@@ -4601,7 +4640,7 @@ class Cmd:
             self.last_result[param] = settable.value
 
         self.poutput()
-        self.poutput(settable_table)
+        self.poutput(settable_table, soft_wrap=False)
         self.poutput()
 
     @classmethod
@@ -5799,7 +5838,7 @@ class Cmd:
 
         :param command: the command being enabled
         """
-        # If the commands is already enabled, then return
+        # If the command is already enabled, then return
         if command not in self.disabled_commands:
             return
 
@@ -5831,11 +5870,17 @@ class Cmd:
 
         :param category: the category to enable
         """
+        # If the category is already enabled, then return
+        if category not in self.disabled_categories:
+            return
+
         for cmd_name in list(self.disabled_commands):
             func = self.disabled_commands[cmd_name].command_function
             if getattr(func, constants.CMD_ATTR_HELP_CATEGORY, None) == category:
                 self.enable_command(cmd_name)
 
+        del self.disabled_categories[category]
+
     def disable_command(self, command: str, message_to_print: str) -> None:
         """Disable a command and overwrite its functions.
 
@@ -5846,7 +5891,7 @@ class Cmd:
                                  command being disabled.
                                  ex: message_to_print = f"{cmd2.COMMAND_NAME} is currently disabled"
         """
-        # If the commands is already disabled, then return
+        # If the command is already disabled, then return
         if command in self.disabled_commands:
             return
 
@@ -5885,6 +5930,10 @@ class Cmd:
                                  of the command being disabled.
                                  ex: message_to_print = f"{cmd2.COMMAND_NAME} is currently disabled"
         """
+        # If the category is already disabled, then return
+        if category in self.disabled_categories:
+            return
+
         all_commands = self.get_all_commands()
 
         for cmd_name in all_commands:
@@ -5892,6 +5941,8 @@ class Cmd:
             if getattr(func, constants.CMD_ATTR_HELP_CATEGORY, None) == category:
                 self.disable_command(cmd_name, message_to_print)
 
+        self.disabled_categories[category] = message_to_print
+
     def _report_disabled_command_usage(self, *_args: Any, message_to_print: str, **_kwargs: Any) -> None:
         """Report when a disabled command has been run or had help called on it.
 

{cmd2-3.1.2 → cmd2-3.1.3}/cmd2/command_definition.py

@@ -63,9 +63,11 @@ def with_default_category(category: str, *, heritable: bool = True) -> Callable[
         # 3. Must be a member of the class being decorated and not one inherited from a parent declaration
         methods = inspect.getmembers(
             cls,
-            predicate=lambda meth: inspect.isfunction(meth)
-            and meth.__name__.startswith(COMMAND_FUNC_PREFIX)
-            and meth in inspect.getmro(cls)[0].__dict__.values(),
+            predicate=lambda meth: (
+                inspect.isfunction(meth)
+                and meth.__name__.startswith(COMMAND_FUNC_PREFIX)
+                and meth in inspect.getmro(cls)[0].__dict__.values()
+            ),
         )
         category_decorator = with_category(category)
         for method in methods:

{cmd2-3.1.2 → cmd2-3.1.3}/cmd2/utils.py

@@ -1,7 +1,6 @@
 """Shared utility functions."""
 
 import argparse
-import collections
 import contextlib
 import functools
 import glob
@@ -192,10 +191,7 @@ def remove_duplicates(list_to_prune: list[_T]) -> list[_T]:
     :param list_to_prune: the list being pruned of duplicates
     :return: The pruned list
     """
-    temp_dict: collections.OrderedDict[_T, Any] = collections.OrderedDict()
-    for item in list_to_prune:
-        temp_dict[item] = None
-
+    temp_dict = dict.fromkeys(list_to_prune)
     return list(temp_dict.keys())
 
 

{cmd2-3.1.2 → cmd2-3.1.3}/cmd2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 3.1.2
+Version: 3.1.3
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT

{cmd2-3.1.2 → cmd2-3.1.3}/package.json

@@ -1,6 +1,6 @@
 {
   "devDependencies": {
-    "prettier": "^3.8.0",
+    "prettier": "^3.8.1",
     "prettier-plugin-toml": "^2.0.6"
   }
 }

{cmd2-3.1.2 → cmd2-3.1.3}/tests/test_cmd2.py

@@ -20,6 +20,7 @@ from cmd2 import (
     COMMAND_NAME,
     Cmd2Style,
     Color,
+    CommandSet,
     RichPrintKwargs,
     clipboard,
     constants,
@@ -3106,6 +3107,16 @@ class DisableCommandsApp(cmd2.Cmd):
         self.poutput("The real has_no_helper_funcs")
 
 
+class DisableCommandSet(CommandSet):
+    """Test registering a command which is in a disabled category"""
+
+    category_name = "CommandSet Test Category"
+
+    @cmd2.with_category(category_name)
+    def do_new_command(self, arg) -> None:
+        self._cmd.poutput("CommandSet function is enabled")
+
+
 @pytest.fixture
 def disable_commands_app():
     return DisableCommandsApp()
@@ -3209,7 +3220,7 @@ def test_enable_enabled_command(disable_commands_app) -> None:
     saved_len = len(disable_commands_app.disabled_commands)
     disable_commands_app.enable_command('has_helper_funcs')
 
-    # The number of disabled_commands should not have changed
+    # The number of disabled commands should not have changed
     assert saved_len == len(disable_commands_app.disabled_commands)
 
 
@@ -3223,7 +3234,7 @@ def test_disable_command_twice(disable_commands_app) -> None:
     message_to_print = 'These commands are currently disabled'
     disable_commands_app.disable_command('has_helper_funcs', message_to_print)
 
-    # The length of disabled_commands should have increased one
+    # The number of disabled commands should have increased one
     new_len = len(disable_commands_app.disabled_commands)
     assert saved_len == new_len - 1
     saved_len = new_len
@@ -3251,6 +3262,50 @@ def test_disabled_message_command_name(disable_commands_app) -> None:
     assert err[0].startswith('has_helper_funcs is currently disabled')
 
 
+def test_register_command_in_enabled_category(disable_commands_app) -> None:
+    disable_commands_app.enable_category(DisableCommandSet.category_name)
+    cs = DisableCommandSet()
+    disable_commands_app.register_command_set(cs)
+
+    out, _err = run_cmd(disable_commands_app, 'new_command')
+    assert out[0] == "CommandSet function is enabled"
+
+
+def test_register_command_in_disabled_category(disable_commands_app) -> None:
+    message_to_print = "CommandSet function is disabled"
+    disable_commands_app.disable_category(DisableCommandSet.category_name, message_to_print)
+    cs = DisableCommandSet()
+    disable_commands_app.register_command_set(cs)
+
+    _out, err = run_cmd(disable_commands_app, 'new_command')
+    assert err[0] == message_to_print
+
+
+def test_enable_enabled_category(disable_commands_app) -> None:
+    # Test enabling a category that is not disabled
+    saved_len = len(disable_commands_app.disabled_categories)
+    disable_commands_app.enable_category('Test Category')
+
+    # The number of disabled categories should not have changed
+    assert saved_len == len(disable_commands_app.disabled_categories)
+
+
+def test_disable_category_twice(disable_commands_app) -> None:
+    saved_len = len(disable_commands_app.disabled_categories)
+    message_to_print = 'These commands are currently disabled'
+    disable_commands_app.disable_category('Test Category', message_to_print)
+
+    # The number of disabled categories should have increased one
+    new_len = len(disable_commands_app.disabled_categories)
+    assert saved_len == new_len - 1
+    saved_len = new_len
+
+    # Disable again and the length should not change
+    disable_commands_app.disable_category('Test Category', message_to_print)
+    new_len = len(disable_commands_app.disabled_categories)
+    assert saved_len == new_len
+
+
 @pytest.mark.parametrize('silence_startup_script', [True, False])
 def test_startup_script(request, capsys, silence_startup_script) -> None:
     test_dir = os.path.dirname(request.module.__file__)

{cmd2-3.1.2 → cmd2-3.1.3}/tests/test_completion.py

@@ -716,19 +716,53 @@ def test_basic_completion_nomatch(cmd2_app) -> None:
     assert cmd2_app.basic_complete(text, line, begidx, endidx, food_item_strs) == []
 
 
-def test_delimiter_completion(cmd2_app) -> None:
+def test_delimiter_completion_partial(cmd2_app) -> None:
+    """Test that a delimiter is added when an item has not been fully completed"""
     text = '/home/'
-    line = f'run_script {text}'
+    line = f'command {text}'
+    endidx = len(line)
+    begidx = endidx - len(text)
+
+    matches = cmd2_app.delimiter_complete(text, line, begidx, endidx, delimited_strs, '/')
+
+    # All matches end with the delimiter
+    matches.sort(key=cmd2_app.default_sort_key)
+    expected_matches = sorted(["/home/other user/", "/home/user/"], key=cmd2_app.default_sort_key)
+
+    cmd2_app.display_matches.sort(key=cmd2_app.default_sort_key)
+    expected_display = sorted(["other user/", "user/"], key=cmd2_app.default_sort_key)
+
+    assert matches == expected_matches
+    assert cmd2_app.display_matches == expected_display
+
+
+def test_delimiter_completion_full(cmd2_app) -> None:
+    """Test that no delimiter is added when an item has been fully completed"""
+    text = '/home/other user/'
+    line = f'command {text}'
     endidx = len(line)
     begidx = endidx - len(text)
 
-    cmd2_app.delimiter_complete(text, line, begidx, endidx, delimited_strs, '/')
+    matches = cmd2_app.delimiter_complete(text, line, begidx, endidx, delimited_strs, '/')
+
+    # No matches end with the delimiter
+    matches.sort(key=cmd2_app.default_sort_key)
+    expected_matches = sorted(["/home/other user/maps", "/home/other user/tests"], key=cmd2_app.default_sort_key)
 
-    # Remove duplicates from display_matches and sort it. This is typically done in complete().
-    display_list = utils.remove_duplicates(cmd2_app.display_matches)
-    display_list = utils.alphabetical_sort(display_list)
+    cmd2_app.display_matches.sort(key=cmd2_app.default_sort_key)
+    expected_display = sorted(["maps", "tests"], key=cmd2_app.default_sort_key)
 
-    assert display_list == ['other user', 'user']
+    assert matches == expected_matches
+    assert cmd2_app.display_matches == expected_display
+
+
+def test_delimiter_completion_nomatch(cmd2_app) -> None:
+    text = '/nothing_to_see'
+    line = f'command {text}'
+    endidx = len(line)
+    begidx = endidx - len(text)
+
+    assert cmd2_app.delimiter_complete(text, line, begidx, endidx, delimited_strs, '/') == []
 
 
 def test_flag_based_completion_single(cmd2_app) -> None:
@@ -964,20 +998,24 @@ def test_add_opening_quote_delimited_no_text(cmd2_app) -> None:
     endidx = len(line)
     begidx = endidx - len(text)
 
-    # The whole list will be returned with no opening quotes added
+    # Matches returned with no opening quote
+    expected_matches = sorted(["/home/other user/", "/home/user/"], key=cmd2_app.default_sort_key)
+    expected_display = sorted(["other user/", "user/"], key=cmd2_app.default_sort_key)
+
     first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
     assert first_match is not None
-    assert cmd2_app.completion_matches == sorted(delimited_strs, key=cmd2_app.default_sort_key)
+    assert cmd2_app.completion_matches == expected_matches
+    assert cmd2_app.display_matches == expected_display
 
 
 def test_add_opening_quote_delimited_nothing_added(cmd2_app) -> None:
-    text = '/ho'
+    text = '/home/'
     line = f'test_delimited {text}'
     endidx = len(line)
     begidx = endidx - len(text)
 
-    expected_matches = sorted(delimited_strs, key=cmd2_app.default_sort_key)
-    expected_display = sorted(['other user', 'user'], key=cmd2_app.default_sort_key)
+    expected_matches = sorted(['/home/other user/', '/home/user/'], key=cmd2_app.default_sort_key)
+    expected_display = sorted(['other user/', 'user/'], key=cmd2_app.default_sort_key)
 
     first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
     assert first_match is not None
@@ -1017,7 +1055,7 @@ def test_add_opening_quote_delimited_text_is_common_prefix(cmd2_app) -> None:
 
 
 def test_add_opening_quote_delimited_space_in_prefix(cmd2_app) -> None:
-    # This test when a space appears before the part of the string that is the display match
+    # This tests when a space appears before the part of the string that is the display match
     text = '/home/oth'
     line = f'test_delimited {text}'
     endidx = len(line)