pw_console/py/command_runner_test.py - pigweed/pigweed - Git at Google

 # Copyright 2022 The Pigweed Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not
 # use this file except in compliance with the License. You may obtain a copy of
 # the License at
 #
 #     https://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 # License for the specific language governing permissions and limitations under
 # the License.
 """Tests for pw_console.command_runner dialog."""

 import logging
 import re
 import unittest
 from typing import Callable, List, Tuple

 from unittest.mock import MagicMock

 from prompt_toolkit.application import create_app_session
 from prompt_toolkit.output import ColorDepth
 # inclusive-language: ignore
 from prompt_toolkit.output import DummyOutput as FakeOutput

 from pw_console.console_app import ConsoleApp
 from pw_console.console_prefs import ConsolePrefs
 from pw_console.text_formatting import (
     flatten_formatted_text_tuples,
     join_adjacent_style_tuples,
 )
 from window_manager_test import target_list_and_pane, window_pane_titles


 def _create_console_app(log_pane_count=2):
     prefs = ConsolePrefs(project_file=False,
                          project_user_file=False,
                          user_file=False)
     prefs.set_code_theme('default')
     console_app = ConsoleApp(color_depth=ColorDepth.DEPTH_8_BIT, prefs=prefs)

     console_app.prefs.reset_config()

     # Setup log panes
     loggers = {}
     for i in range(log_pane_count):
         loggers['LogPane-{}'.format(i)] = [
             logging.getLogger('test_log{}'.format(i))
         ]
     for window_title, logger_instances in loggers.items():
         console_app.add_log_handler(window_title, logger_instances)

     return console_app


 class TestCommandRunner(unittest.TestCase):
     """Tests for CommandRunner."""
     def setUp(self):
         self.maxDiff = None  # pylint: disable=invalid-name

     def test_flatten_menu_items(self) -> None:
         with create_app_session(output=FakeOutput()):
             console_app = _create_console_app(log_pane_count=2)
             flattened_menu_items = [
                 text for text, handler in
                 console_app.command_runner.load_menu_items()
             ]

             # Check some common menu items exist.
             self.assertIn('[File] > Open Logger', flattened_menu_items)
             self.assertIn('[File] > Themes > UI Themes > High Contrast',
                           flattened_menu_items)
             self.assertIn('[Help] > User Guide', flattened_menu_items)
             self.assertIn('[Help] > Keyboard Shortcuts', flattened_menu_items)
             # Check for log windows
             self.assertRegex(
                 '\n'.join(flattened_menu_items),
                 re.compile(r'^\[Windows\] > .* LogPane-[0-9]+ > .*$',
                            re.MULTILINE),
             )

     def test_filter_and_highlight_matches(self) -> None:
         """Check filtering matches and highlighting works correctly."""
         with create_app_session(output=FakeOutput()):
             console_app = _create_console_app(log_pane_count=2)
             command_runner = console_app.command_runner

             command_runner.filter_completions = MagicMock(
                 wraps=command_runner.filter_completions)
             command_runner.width = 20

             # Define custom completion items
             def empty_handler() -> None:
                 return None

             def get_completions() -> List[Tuple[str, Callable]]:
                 return [
                     ('[File] > Open Logger', empty_handler),
                     ('[Windows] > 1: Host Logs > Show/Hide', empty_handler),
                     ('[Windows] > 2: Device Logs > Show/Hide', empty_handler),
                     ('[Help] > User Guide', empty_handler),
                 ]

             command_runner.filter_completions.assert_not_called()
             command_runner.set_completions(window_title='Test Completions',
                                            load_completions=get_completions)
             command_runner.filter_completions.assert_called_once()
             command_runner.filter_completions.reset_mock()

             # Input field should be empty
             self.assertEqual(command_runner.input_field.buffer.text, '')
             # Flatten resulting formatted text
             result_items = join_adjacent_style_tuples(
                 flatten_formatted_text_tuples(
                     command_runner.completion_fragments))

             # index 0: the selected line
             # index 1: the rest of the completions with line breaks
             self.assertEqual(len(result_items), 2)
             first_item_style = result_items[0][0]
             first_item_text = result_items[0][1]
             second_item_text = result_items[1][1]
             # Check expected number of lines are present
             self.assertEqual(len(first_item_text.splitlines()), 1)
             self.assertEqual(len(second_item_text.splitlines()), 3)
             # First line is highlighted as a selected item
             self.assertEqual(first_item_style,
                              'class:command-runner-selected-item')
             self.assertIn('[File] > Open Logger', first_item_text)

             # Type: file open
             command_runner.input_field.buffer.text = 'file open'
             self.assertEqual(command_runner.input_field.buffer.text,
                              'file open')
             # Run the filter
             command_runner.filter_completions()
             # Flatten resulting formatted text
             result_items = join_adjacent_style_tuples(
                 flatten_formatted_text_tuples(
                     command_runner.completion_fragments))
             # Check file and open are highlighted
             self.assertEqual(
                 result_items[:4],
                 [
                     ('class:command-runner-selected-item', '['),
                     ('class:command-runner-selected-item '
                      'class:command-runner-fuzzy-highlight-0 ', 'File'),
                     ('class:command-runner-selected-item', '] > '),
                     ('class:command-runner-selected-item '
                      'class:command-runner-fuzzy-highlight-1 ', 'Open'),
                 ],
             )

             # Type: open file
             command_runner.input_field.buffer.text = 'open file'
             # Run the filter
             command_runner.filter_completions()
             result_items = join_adjacent_style_tuples(
                 flatten_formatted_text_tuples(
                     command_runner.completion_fragments))
             # Check file and open are highlighted, the fuzzy-highlight class
             # should be swapped.
             self.assertEqual(
                 result_items[:4],
                 [
                     ('class:command-runner-selected-item', '['),
                     ('class:command-runner-selected-item '
                      'class:command-runner-fuzzy-highlight-1 ', 'File'),
                     ('class:command-runner-selected-item', '] > '),
                     ('class:command-runner-selected-item '
                      'class:command-runner-fuzzy-highlight-0 ', 'Open'),
                 ],
             )

             # Clear input
             command_runner._reset_selected_item()  # pylint: disable=protected-access
             command_runner.filter_completions()
             result_items = join_adjacent_style_tuples(
                 flatten_formatted_text_tuples(
                     command_runner.completion_fragments))
             self.assertEqual(len(first_item_text.splitlines()), 1)
             self.assertEqual(len(second_item_text.splitlines()), 3)

             # Press down (select the next item)
             command_runner._next_item()  # pylint: disable=protected-access
             # Filter and check results
             command_runner.filter_completions()
             result_items = join_adjacent_style_tuples(
                 flatten_formatted_text_tuples(
                     command_runner.completion_fragments))
             self.assertEqual(len(result_items), 3)
             # First line - not selected
             self.assertEqual(result_items[0], ('', '[File] > Open Logger\n'))
             # Second line - is selected
             self.assertEqual(result_items[1],
                              ('class:command-runner-selected-item',
                               '[Windows] > 1: Host Logs > Show/Hide\n'))
             # Third and fourth lines separated by \n - not selected
             self.assertEqual(result_items[2],
                              ('', '[Windows] > 2: Device Logs > Show/Hide\n'
                               '[Help] > User Guide'))

     def test_run_action(self) -> None:
         """Check running an action works correctly."""
         with create_app_session(output=FakeOutput()):
             console_app = _create_console_app(log_pane_count=2)
             command_runner = console_app.command_runner
             self.assertEqual(
                 window_pane_titles(console_app.window_manager),
                 [
                     # Split 1
                     [
                         'LogPane-1 - test_log1',
                         'LogPane-0 - test_log0',
                         'Python Repl - ',
                     ],
                 ],
             )
             command_runner.open_dialog()
             # Set LogPane-1 as the focused window pane
             target_list_and_pane(console_app.window_manager, 0, 0)

             command_runner.input_field.buffer.text = 'move right'

             # pylint: disable=protected-access
             command_runner._make_regexes = MagicMock(
                 wraps=command_runner._make_regexes)
             # pylint: enable=protected-access
             command_runner.filter_completions()
             # Filter should only be re-run if input text changed
             command_runner.filter_completions()
             command_runner._make_regexes.assert_called_once()  # pylint: disable=protected-access

             self.assertIn('[View] > Move Window Right',
                           command_runner.selected_item_text)
             # Run the Move Window Right action
             command_runner._run_selected_item()  # pylint: disable=protected-access
             # Dialog should be closed
             self.assertFalse(command_runner.show_dialog)
             # LogPane-1 should be moved to the right in it's own split
             self.assertEqual(
                 window_pane_titles(console_app.window_manager),
                 [
                     # Split 1
                     [
                         'LogPane-0 - test_log0',
                         'Python Repl - ',
                     ],
                     # Split 2
                     [
                         'LogPane-1 - test_log1',
                     ],
                 ],
             )


 if __name__ == '__main__':
     unittest.main()
	# Copyright 2022 The Pigweed Authors
	#
	# Licensed under the Apache License, Version 2.0 (the "License"); you may not
	# use this file except in compliance with the License. You may obtain a copy of
	# the License at
	#
	# https://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	# License for the specific language governing permissions and limitations under
	# the License.
	"""Tests for pw_console.command_runner dialog."""

	import logging
	import re
	import unittest
	from typing import Callable, List, Tuple

	from unittest.mock import MagicMock

	from prompt_toolkit.application import create_app_session
	from prompt_toolkit.output import ColorDepth
	# inclusive-language: ignore
	from prompt_toolkit.output import DummyOutput as FakeOutput

	from pw_console.console_app import ConsoleApp
	from pw_console.console_prefs import ConsolePrefs
	from pw_console.text_formatting import (
	flatten_formatted_text_tuples,
	join_adjacent_style_tuples,
	)
	from window_manager_test import target_list_and_pane, window_pane_titles


	def _create_console_app(log_pane_count=2):
	prefs = ConsolePrefs(project_file=False,
	project_user_file=False,
	user_file=False)
	prefs.set_code_theme('default')
	console_app = ConsoleApp(color_depth=ColorDepth.DEPTH_8_BIT, prefs=prefs)

	console_app.prefs.reset_config()

	# Setup log panes
	loggers = {}
	for i in range(log_pane_count):
	loggers['LogPane-{}'.format(i)] = [
	logging.getLogger('test_log{}'.format(i))
	]
	for window_title, logger_instances in loggers.items():
	console_app.add_log_handler(window_title, logger_instances)

	return console_app


	class TestCommandRunner(unittest.TestCase):
	"""Tests for CommandRunner."""
	def setUp(self):
	self.maxDiff = None # pylint: disable=invalid-name

	def test_flatten_menu_items(self) -> None:
	with create_app_session(output=FakeOutput()):
	console_app = _create_console_app(log_pane_count=2)
	flattened_menu_items = [
	text for text, handler in
	console_app.command_runner.load_menu_items()
	]

	# Check some common menu items exist.
	self.assertIn('[File] > Open Logger', flattened_menu_items)
	self.assertIn('[File] > Themes > UI Themes > High Contrast',
	flattened_menu_items)
	self.assertIn('[Help] > User Guide', flattened_menu_items)
	self.assertIn('[Help] > Keyboard Shortcuts', flattened_menu_items)
	# Check for log windows
	self.assertRegex(
	'\n'.join(flattened_menu_items),
	re.compile(r'^\[Windows\] > .* LogPane-[0-9]+ > .*$',
	re.MULTILINE),
	)

	def test_filter_and_highlight_matches(self) -> None:
	"""Check filtering matches and highlighting works correctly."""
	with create_app_session(output=FakeOutput()):
	console_app = _create_console_app(log_pane_count=2)
	command_runner = console_app.command_runner

	command_runner.filter_completions = MagicMock(
	wraps=command_runner.filter_completions)
	command_runner.width = 20

	# Define custom completion items
	def empty_handler() -> None:
	return None

	def get_completions() -> List[Tuple[str, Callable]]:
	return [
	('[File] > Open Logger', empty_handler),
	('[Windows] > 1: Host Logs > Show/Hide', empty_handler),
	('[Windows] > 2: Device Logs > Show/Hide', empty_handler),
	('[Help] > User Guide', empty_handler),
	]

	command_runner.filter_completions.assert_not_called()
	command_runner.set_completions(window_title='Test Completions',
	load_completions=get_completions)
	command_runner.filter_completions.assert_called_once()
	command_runner.filter_completions.reset_mock()

	# Input field should be empty
	self.assertEqual(command_runner.input_field.buffer.text, '')
	# Flatten resulting formatted text
	result_items = join_adjacent_style_tuples(
	flatten_formatted_text_tuples(
	command_runner.completion_fragments))

	# index 0: the selected line
	# index 1: the rest of the completions with line breaks
	self.assertEqual(len(result_items), 2)
	first_item_style = result_items[0][0]
	first_item_text = result_items[0][1]
	second_item_text = result_items[1][1]
	# Check expected number of lines are present
	self.assertEqual(len(first_item_text.splitlines()), 1)
	self.assertEqual(len(second_item_text.splitlines()), 3)
	# First line is highlighted as a selected item
	self.assertEqual(first_item_style,
	'class:command-runner-selected-item')
	self.assertIn('[File] > Open Logger', first_item_text)

	# Type: file open
	command_runner.input_field.buffer.text = 'file open'
	self.assertEqual(command_runner.input_field.buffer.text,
	'file open')
	# Run the filter
	command_runner.filter_completions()
	# Flatten resulting formatted text
	result_items = join_adjacent_style_tuples(
	flatten_formatted_text_tuples(
	command_runner.completion_fragments))
	# Check file and open are highlighted
	self.assertEqual(
	result_items[:4],
	[
	('class:command-runner-selected-item', '['),
	('class:command-runner-selected-item '
	'class:command-runner-fuzzy-highlight-0 ', 'File'),
	('class:command-runner-selected-item', '] > '),
	('class:command-runner-selected-item '
	'class:command-runner-fuzzy-highlight-1 ', 'Open'),
	],
	)

	# Type: open file
	command_runner.input_field.buffer.text = 'open file'
	# Run the filter
	command_runner.filter_completions()
	result_items = join_adjacent_style_tuples(
	flatten_formatted_text_tuples(
	command_runner.completion_fragments))
	# Check file and open are highlighted, the fuzzy-highlight class
	# should be swapped.
	self.assertEqual(
	result_items[:4],
	[
	('class:command-runner-selected-item', '['),
	('class:command-runner-selected-item '
	'class:command-runner-fuzzy-highlight-1 ', 'File'),
	('class:command-runner-selected-item', '] > '),
	('class:command-runner-selected-item '
	'class:command-runner-fuzzy-highlight-0 ', 'Open'),
	],
	)

	# Clear input
	command_runner._reset_selected_item() # pylint: disable=protected-access
	command_runner.filter_completions()
	result_items = join_adjacent_style_tuples(
	flatten_formatted_text_tuples(
	command_runner.completion_fragments))
	self.assertEqual(len(first_item_text.splitlines()), 1)
	self.assertEqual(len(second_item_text.splitlines()), 3)

	# Press down (select the next item)
	command_runner._next_item() # pylint: disable=protected-access
	# Filter and check results
	command_runner.filter_completions()
	result_items = join_adjacent_style_tuples(
	flatten_formatted_text_tuples(
	command_runner.completion_fragments))
	self.assertEqual(len(result_items), 3)
	# First line - not selected
	self.assertEqual(result_items[0], ('', '[File] > Open Logger\n'))
	# Second line - is selected
	self.assertEqual(result_items[1],
	('class:command-runner-selected-item',
	'[Windows] > 1: Host Logs > Show/Hide\n'))
	# Third and fourth lines separated by \n - not selected
	self.assertEqual(result_items[2],
	('', '[Windows] > 2: Device Logs > Show/Hide\n'
	'[Help] > User Guide'))

	def test_run_action(self) -> None:
	"""Check running an action works correctly."""
	with create_app_session(output=FakeOutput()):
	console_app = _create_console_app(log_pane_count=2)
	command_runner = console_app.command_runner
	self.assertEqual(
	window_pane_titles(console_app.window_manager),
	[
	# Split 1
	[
	'LogPane-1 - test_log1',
	'LogPane-0 - test_log0',
	'Python Repl - ',
	],
	],
	)
	command_runner.open_dialog()
	# Set LogPane-1 as the focused window pane
	target_list_and_pane(console_app.window_manager, 0, 0)

	command_runner.input_field.buffer.text = 'move right'

	# pylint: disable=protected-access
	command_runner._make_regexes = MagicMock(
	wraps=command_runner._make_regexes)
	# pylint: enable=protected-access
	command_runner.filter_completions()
	# Filter should only be re-run if input text changed
	command_runner.filter_completions()
	command_runner._make_regexes.assert_called_once() # pylint: disable=protected-access

	self.assertIn('[View] > Move Window Right',
	command_runner.selected_item_text)
	# Run the Move Window Right action
	command_runner._run_selected_item() # pylint: disable=protected-access
	# Dialog should be closed
	self.assertFalse(command_runner.show_dialog)
	# LogPane-1 should be moved to the right in it's own split
	self.assertEqual(
	window_pane_titles(console_app.window_manager),
	[
	# Split 1
	[
	'LogPane-0 - test_log0',
	'Python Repl - ',
	],
	# Split 2
	[
	'LogPane-1 - test_log1',
	],
	],
	)


	if __name__ == '__main__':
	unittest.main()