adjusted formating in test_shortcuts.py

IPython/terminal/tests/test_shortcuts.py

@@ -1,485 +1,485 b''
 import pytest
 from IPython.terminal.shortcuts.auto_suggest import (
     accept,
     accept_or_jump_to_end,
     accept_token,
     accept_character,
     accept_word,
     accept_and_keep_cursor,
     discard,
     NavigableAutoSuggestFromHistory,
     swap_autosuggestion_up,
     swap_autosuggestion_down,
 )
 from IPython.terminal.shortcuts.auto_match import skip_over
-from IPython.terminal.shortcuts import create_ipython_shortcuts,reset_search_buffer
+from IPython.terminal.shortcuts import create_ipython_shortcuts, reset_search_buffer
 
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.document import Document
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 from prompt_toolkit.enums import DEFAULT_BUFFER
 
 from unittest.mock import patch, Mock
 
 
 def test_deprected():
     import IPython.terminal.shortcuts.auto_suggest as iptsa
 
     with pytest.warns(DeprecationWarning, match=r"8\.12.+accept_or_jump_to_end"):
         iptsa.accept_in_vi_insert_mode
 
 
 def make_event(text, cursor, suggestion):
     event = Mock()
     event.current_buffer = Mock()
     event.current_buffer.suggestion = Mock()
     event.current_buffer.text = text
     event.current_buffer.cursor_position = cursor
     event.current_buffer.suggestion.text = suggestion
     event.current_buffer.document = Document(text=text, cursor_position=cursor)
     return event
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected",
     [
         ("", "def out(tag: str, n=50):", "def out(tag: str, n=50):"),
         ("def ", "out(tag: str, n=50):", "out(tag: str, n=50):"),
     ],
 )
 def test_accept(text, suggestion, expected):
     event = make_event(text, len(text), suggestion)
     buffer = event.current_buffer
     buffer.insert_text = Mock()
     accept(event)
     assert buffer.insert_text.called
     assert buffer.insert_text.call_args[0] == (expected,)
 
 
 @pytest.mark.parametrize(
     "text, suggestion",
     [
         ("", "def out(tag: str, n=50):"),
         ("def ", "out(tag: str, n=50):"),
     ],
 )
 def test_discard(text, suggestion):
     event = make_event(text, len(text), suggestion)
     buffer = event.current_buffer
     buffer.insert_text = Mock()
     discard(event)
     assert not buffer.insert_text.called
     assert buffer.suggestion is None
 
 
 @pytest.mark.parametrize(
     "text, cursor, suggestion, called",
     [
         ("123456", 6, "123456789", True),
         ("123456", 3, "123456789", False),
         ("123456   \n789", 6, "123456789", True),
     ],
 )
 def test_autosuggest_at_EOL(text, cursor, suggestion, called):
     """
     test that autosuggest is only applied at end of line.
     """
 
     event = make_event(text, cursor, suggestion)
     event.current_buffer.insert_text = Mock()
     accept_or_jump_to_end(event)
     if called:
         event.current_buffer.insert_text.assert_called()
     else:
         event.current_buffer.insert_text.assert_not_called()
         # event.current_buffer.document.get_end_of_line_position.assert_called()
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected",
     [
         ("", "def out(tag: str, n=50):", "def "),
         ("d", "ef out(tag: str, n=50):", "ef "),
         ("de ", "f out(tag: str, n=50):", "f "),
         ("def", " out(tag: str, n=50):", " "),
         ("def ", "out(tag: str, n=50):", "out("),
         ("def o", "ut(tag: str, n=50):", "ut("),
         ("def ou", "t(tag: str, n=50):", "t("),
         ("def out", "(tag: str, n=50):", "("),
         ("def out(", "tag: str, n=50):", "tag: "),
         ("def out(t", "ag: str, n=50):", "ag: "),
         ("def out(ta", "g: str, n=50):", "g: "),
         ("def out(tag", ": str, n=50):", ": "),
         ("def out(tag:", " str, n=50):", " "),
         ("def out(tag: ", "str, n=50):", "str, "),
         ("def out(tag: s", "tr, n=50):", "tr, "),
         ("def out(tag: st", "r, n=50):", "r, "),
         ("def out(tag: str", ", n=50):", ", n"),
         ("def out(tag: str,", " n=50):", " n"),
         ("def out(tag: str, ", "n=50):", "n="),
         ("def out(tag: str, n", "=50):", "="),
         ("def out(tag: str, n=", "50):", "50)"),
         ("def out(tag: str, n=5", "0):", "0)"),
         ("def out(tag: str, n=50", "):", "):"),
         ("def out(tag: str, n=50)", ":", ":"),
     ],
 )
 def test_autosuggest_token(text, suggestion, expected):
     event = make_event(text, len(text), suggestion)
     event.current_buffer.insert_text = Mock()
     accept_token(event)
     assert event.current_buffer.insert_text.called
     assert event.current_buffer.insert_text.call_args[0] == (expected,)
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected",
     [
         ("", "def out(tag: str, n=50):", "d"),
         ("d", "ef out(tag: str, n=50):", "e"),
         ("de ", "f out(tag: str, n=50):", "f"),
         ("def", " out(tag: str, n=50):", " "),
     ],
 )
 def test_accept_character(text, suggestion, expected):
     event = make_event(text, len(text), suggestion)
     event.current_buffer.insert_text = Mock()
     accept_character(event)
     assert event.current_buffer.insert_text.called
     assert event.current_buffer.insert_text.call_args[0] == (expected,)
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected",
     [
         ("", "def out(tag: str, n=50):", "def "),
         ("d", "ef out(tag: str, n=50):", "ef "),
         ("de", "f out(tag: str, n=50):", "f "),
         ("def", " out(tag: str, n=50):", " "),
         # (this is why we also have accept_token)
         ("def ", "out(tag: str, n=50):", "out(tag: "),
     ],
 )
 def test_accept_word(text, suggestion, expected):
     event = make_event(text, len(text), suggestion)
     event.current_buffer.insert_text = Mock()
     accept_word(event)
     assert event.current_buffer.insert_text.called
     assert event.current_buffer.insert_text.call_args[0] == (expected,)
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected, cursor",
     [
         ("", "def out(tag: str, n=50):", "def out(tag: str, n=50):", 0),
         ("def ", "out(tag: str, n=50):", "out(tag: str, n=50):", 4),
     ],
 )
 def test_accept_and_keep_cursor(text, suggestion, expected, cursor):
     event = make_event(text, cursor, suggestion)
     buffer = event.current_buffer
     buffer.insert_text = Mock()
     accept_and_keep_cursor(event)
     assert buffer.insert_text.called
     assert buffer.insert_text.call_args[0] == (expected,)
     assert buffer.cursor_position == cursor
 
 
 def test_autosuggest_token_empty():
     full = "def out(tag: str, n=50):"
     event = make_event(full, len(full), "")
     event.current_buffer.insert_text = Mock()
 
     with patch(
         "prompt_toolkit.key_binding.bindings.named_commands.forward_word"
     ) as forward_word:
         accept_token(event)
         assert not event.current_buffer.insert_text.called
         assert forward_word.called
 
 
 def test_reset_search_buffer():
     event_with_text = Mock()
     event_with_text.current_buffer.document.text = "some text"
     event_with_text.current_buffer.reset = Mock()
 
     event_empty = Mock()
     event_empty.current_buffer.document.text = ""
     event_empty.app.layout.focus = Mock()
 
     reset_search_buffer(event_with_text)
     event_with_text.current_buffer.reset.assert_called_once()
 
     reset_search_buffer(event_empty)
     event_empty.app.layout.focus.assert_called_once_with(DEFAULT_BUFFER)
 
 
 def test_other_providers():
     """Ensure that swapping autosuggestions does not break with other providers"""
     provider = AutoSuggestFromHistory()
     ip = get_ipython()
     ip.auto_suggest = provider
     event = Mock()
     event.current_buffer = Buffer()
     assert swap_autosuggestion_up(event) is None
     assert swap_autosuggestion_down(event) is None
 
 
 async def test_navigable_provider():
     provider = NavigableAutoSuggestFromHistory()
     history = InMemoryHistory(history_strings=["very_a", "very", "very_b", "very_c"])
     buffer = Buffer(history=history)
     ip = get_ipython()
     ip.auto_suggest = provider
 
     async for _ in history.load():
         pass
 
     buffer.cursor_position = 5
     buffer.text = "very"
 
     up = swap_autosuggestion_up
     down = swap_autosuggestion_down
 
     event = Mock()
     event.current_buffer = buffer
 
     def get_suggestion():
         suggestion = provider.get_suggestion(buffer, buffer.document)
         buffer.suggestion = suggestion
         return suggestion
 
     assert get_suggestion().text == "_c"
 
     # should go up
     up(event)
     assert get_suggestion().text == "_b"
 
     # should skip over 'very' which is identical to buffer content
     up(event)
     assert get_suggestion().text == "_a"
 
     # should cycle back to beginning
     up(event)
     assert get_suggestion().text == "_c"
 
     # should cycle back through end boundary
     down(event)
     assert get_suggestion().text == "_a"
 
     down(event)
     assert get_suggestion().text == "_b"
 
     down(event)
     assert get_suggestion().text == "_c"
 
     down(event)
     assert get_suggestion().text == "_a"
 
 
 async def test_navigable_provider_multiline_entries():
     provider = NavigableAutoSuggestFromHistory()
     history = InMemoryHistory(history_strings=["very_a\nvery_b", "very_c"])
     buffer = Buffer(history=history)
     ip = get_ipython()
     ip.auto_suggest = provider
 
     async for _ in history.load():
         pass
 
     buffer.cursor_position = 5
     buffer.text = "very"
     up = swap_autosuggestion_up
     down = swap_autosuggestion_down
 
     event = Mock()
     event.current_buffer = buffer
 
     def get_suggestion():
         suggestion = provider.get_suggestion(buffer, buffer.document)
         buffer.suggestion = suggestion
         return suggestion
 
     assert get_suggestion().text == "_c"
 
     up(event)
     assert get_suggestion().text == "_b"
 
     up(event)
     assert get_suggestion().text == "_a"
 
     down(event)
     assert get_suggestion().text == "_b"
 
     down(event)
     assert get_suggestion().text == "_c"
 
 
 def create_session_mock():
     session = Mock()
     session.default_buffer = Buffer()
     return session
 
 
 def test_navigable_provider_connection():
     provider = NavigableAutoSuggestFromHistory()
     provider.skip_lines = 1
 
     session_1 = create_session_mock()
     provider.connect(session_1)
 
     assert provider.skip_lines == 1
     session_1.default_buffer.on_text_insert.fire()
     assert provider.skip_lines == 0
 
     session_2 = create_session_mock()
     provider.connect(session_2)
     provider.skip_lines = 2
 
     assert provider.skip_lines == 2
     session_2.default_buffer.on_text_insert.fire()
     assert provider.skip_lines == 0
 
     provider.skip_lines = 3
     provider.disconnect()
     session_1.default_buffer.on_text_insert.fire()
     session_2.default_buffer.on_text_insert.fire()
     assert provider.skip_lines == 3
 
 
 @pytest.fixture
 def ipython_with_prompt():
     ip = get_ipython()
     ip.pt_app = Mock()
     ip.pt_app.key_bindings = create_ipython_shortcuts(ip)
     try:
         yield ip
     finally:
         ip.pt_app = None
 
 
 def find_bindings_by_command(command):
     ip = get_ipython()
     return [
         binding
         for binding in ip.pt_app.key_bindings.bindings
         if binding.handler == command
     ]
 
 
 def test_modify_unique_shortcut(ipython_with_prompt):
     original = find_bindings_by_command(accept_token)
     assert len(original) == 1
 
     ipython_with_prompt.shortcuts = [
         {"command": "IPython:auto_suggest.accept_token", "new_keys": ["a", "b", "c"]}
     ]
     matched = find_bindings_by_command(accept_token)
     assert len(matched) == 1
     assert list(matched[0].keys) == ["a", "b", "c"]
     assert list(matched[0].keys) != list(original[0].keys)
     assert matched[0].filter == original[0].filter
 
     ipython_with_prompt.shortcuts = [
         {"command": "IPython:auto_suggest.accept_token", "new_filter": "always"}
     ]
     matched = find_bindings_by_command(accept_token)
     assert len(matched) == 1
     assert list(matched[0].keys) != ["a", "b", "c"]
     assert list(matched[0].keys) == list(original[0].keys)
     assert matched[0].filter != original[0].filter
 
 
 def test_disable_shortcut(ipython_with_prompt):
     matched = find_bindings_by_command(accept_token)
     assert len(matched) == 1
 
     ipython_with_prompt.shortcuts = [
         {"command": "IPython:auto_suggest.accept_token", "new_keys": []}
     ]
     matched = find_bindings_by_command(accept_token)
     assert len(matched) == 0
 
     ipython_with_prompt.shortcuts = []
     matched = find_bindings_by_command(accept_token)
     assert len(matched) == 1
 
 
 def test_modify_shortcut_with_filters(ipython_with_prompt):
     matched = find_bindings_by_command(skip_over)
     matched_keys = {m.keys[0] for m in matched}
     assert matched_keys == {")", "]", "}", "'", '"'}
 
     with pytest.raises(ValueError, match="Multiple shortcuts matching"):
         ipython_with_prompt.shortcuts = [
             {"command": "IPython:auto_match.skip_over", "new_keys": ["x"]}
         ]
 
     ipython_with_prompt.shortcuts = [
         {
             "command": "IPython:auto_match.skip_over",
             "new_keys": ["x"],
             "match_filter": "focused_insert & auto_match & followed_by_single_quote",
         }
     ]
     matched = find_bindings_by_command(skip_over)
     matched_keys = {m.keys[0] for m in matched}
     assert matched_keys == {")", "]", "}", "x", '"'}
 
 
 def example_command():
     pass
 
 
 def test_add_shortcut_for_new_command(ipython_with_prompt):
     matched = find_bindings_by_command(example_command)
     assert len(matched) == 0
 
     with pytest.raises(ValueError, match="example_command is not a known"):
         ipython_with_prompt.shortcuts = [
             {"command": "example_command", "new_keys": ["x"]}
         ]
     matched = find_bindings_by_command(example_command)
     assert len(matched) == 0
 
 
 def test_modify_shortcut_failure(ipython_with_prompt):
     with pytest.raises(ValueError, match="No shortcuts matching"):
         ipython_with_prompt.shortcuts = [
             {
                 "command": "IPython:auto_match.skip_over",
                 "match_keys": ["x"],
                 "new_keys": ["y"],
             }
         ]
 
 
 def test_add_shortcut_for_existing_command(ipython_with_prompt):
     matched = find_bindings_by_command(skip_over)
     assert len(matched) == 5
 
     with pytest.raises(ValueError, match="Cannot add a shortcut without keys"):
         ipython_with_prompt.shortcuts = [
             {"command": "IPython:auto_match.skip_over", "new_keys": [], "create": True}
         ]
 
     ipython_with_prompt.shortcuts = [
         {"command": "IPython:auto_match.skip_over", "new_keys": ["x"], "create": True}
     ]
     matched = find_bindings_by_command(skip_over)
     assert len(matched) == 6
 
     ipython_with_prompt.shortcuts = []
     matched = find_bindings_by_command(skip_over)
     assert len(matched) == 5
 
 
 def test_setting_shortcuts_before_pt_app_init():
     ipython = get_ipython()
     assert ipython.pt_app is None
     shortcuts = [
         {"command": "IPython:auto_match.skip_over", "new_keys": ["x"], "create": True}
     ]
     ipython.shortcuts = shortcuts
     assert ipython.shortcuts == shortcuts