From f98708380ada82892f925fb9e4b31c3a14be8861 Mon Sep 17 00:00:00 2001 From: Mahfuza Humayra Mohona Date: Wed, 28 Aug 2024 08:21:53 +0600 Subject: [PATCH 1/2] more tests --- src/scribe_data/cli/cli_utils.py | 71 ++++++------- tests/cli/test_convert.py | 43 ++++---- tests/cli/test_utils.py | 164 +++++++++++++++++++++++++++++++ 3 files changed, 222 insertions(+), 56 deletions(-) create mode 100644 tests/cli/test_utils.py diff --git a/src/scribe_data/cli/cli_utils.py b/src/scribe_data/cli/cli_utils.py index cc0c6fef..51094027 100644 --- a/src/scribe_data/cli/cli_utils.py +++ b/src/scribe_data/cli/cli_utils.py @@ -81,44 +81,45 @@ def print_formatted_data(data: Union[dict, list], data_type: str) -> None: print(f"No data available for data type '{data_type}'.") return - max_key_length = max((len(key) for key in data.keys()), default=0) - - if data_type == "autosuggestions": - for key, value in data.items(): - print(f"{key:<{max_key_length}} : {', '.join(value)}") - - elif data_type == "emoji_keywords": - for key, value in data.items(): - emojis = [item["emoji"] for item in value] - print(f"{key:<{max_key_length}} : {' '.join(emojis)}") - - elif data_type in {"prepositions", "translations"}: - for key, value in data.items(): - print(f"{key:<{max_key_length}} : {value}") - - elif isinstance(data, dict): - for key, value in data.items(): - if isinstance(value, dict): - print(f"{key:<{max_key_length}} : ") - max_sub_key_length = max( - (len(sub_key) for sub_key in value.keys()), default=0 - ) - for sub_key, sub_value in value.items(): - print(f" {sub_key:<{max_sub_key_length}} : {sub_value}") - - elif isinstance(value, list): - print(f"{key:<{max_key_length}} : ") - for item in value: - if isinstance(item, dict): - for sub_key, sub_value in item.items(): - print(f" {sub_key:<{max_key_length}} : {sub_value}") - - else: - print(f" {item}") + if isinstance(data, dict): + max_key_length = max((len(key) for key in data.keys()), default=0) - else: + if data_type == "autosuggestions": + for key, value in data.items(): + print(f"{key:<{max_key_length}} : {', '.join(value)}") + + elif data_type == "emoji_keywords": + for key, value in data.items(): + emojis = [item["emoji"] for item in value] + print(f"{key:<{max_key_length}} : {' '.join(emojis)}") + + elif data_type in {"prepositions", "translations"}: + for key, value in data.items(): print(f"{key:<{max_key_length}} : {value}") + else: + for key, value in data.items(): + if isinstance(value, dict): + print(f"{key:<{max_key_length}} : ") + max_sub_key_length = max( + (len(sub_key) for sub_key in value.keys()), default=0 + ) + for sub_key, sub_value in value.items(): + print(f" {sub_key:<{max_sub_key_length}} : {sub_value}") + + elif isinstance(value, list): + print(f"{key:<{max_key_length}} : ") + for item in value: + if isinstance(item, dict): + for sub_key, sub_value in item.items(): + print(f" {sub_key:<{max_key_length}} : {sub_value}") + + else: + print(f" {item}") + + else: + print(f"{key:<{max_key_length}} : {value}") + elif isinstance(data, list): for item in data: if isinstance(item, dict): diff --git a/tests/cli/test_convert.py b/tests/cli/test_convert.py index c77a0b3a..520af3e6 100644 --- a/tests/cli/test_convert.py +++ b/tests/cli/test_convert.py @@ -23,50 +23,51 @@ import unittest from unittest.mock import patch from pathlib import Path -from scribe_data.cli.convert import export_json, convert_to_sqlite +from scribe_data.cli.convert import export_json, convert_to_sqlite -class TestConvert(unittest.TestCase): - @patch('scribe_data.cli.convert.Path') - @patch('scribe_data.cli.convert.data_to_sqlite') - @patch('shutil.copy') +class TestConvert(unittest.TestCase): + @patch("scribe_data.cli.convert.Path") + @patch("scribe_data.cli.convert.data_to_sqlite") + @patch("shutil.copy") def test_convert_to_sqlite(self, mock_shutil_copy, mock_data_to_sqlite, mock_path): mock_path.return_value.exists.return_value = True - convert_to_sqlite('english', 'nouns', '/output', True) + convert_to_sqlite("english", "nouns", "/output", True) - mock_data_to_sqlite.assert_called_with(['english'], ['nouns']) + mock_data_to_sqlite.assert_called_with(["english"], ["nouns"]) mock_shutil_copy.assert_called() - @patch('scribe_data.cli.convert.Path') - @patch('scribe_data.cli.convert.data_to_sqlite') + @patch("scribe_data.cli.convert.Path") + @patch("scribe_data.cli.convert.data_to_sqlite") def test_convert_to_sqlite_no_output_dir(self, mock_data_to_sqlite, mock_path): - convert_to_sqlite('english', 'nouns', None, True) + convert_to_sqlite("english", "nouns", None, True) - mock_data_to_sqlite.assert_called_with(['english'], ['nouns']) + mock_data_to_sqlite.assert_called_with(["english"], ["nouns"]) mock_path.assert_not_called() - @patch('scribe_data.cli.convert.Path') - @patch('scribe_data.cli.convert.data_to_sqlite') - @patch('scribe_data.cli.convert.get_language_iso') - @patch('shutil.copy') - def test_convert_to_sqlite_with_language_iso(self, mock_copy, mock_get_language_iso, mock_data_to_sqlite, mock_path): + @patch("scribe_data.cli.convert.Path") + @patch("scribe_data.cli.convert.data_to_sqlite") + @patch("scribe_data.cli.convert.get_language_iso") + @patch("shutil.copy") + def test_convert_to_sqlite_with_language_iso( + self, mock_copy, mock_get_language_iso, mock_data_to_sqlite, mock_path + ): mock_get_language_iso.return_value = "en" mock_path.return_value.exists.return_value = True - + convert_to_sqlite("English", "data_type", "/output", True) - + mock_data_to_sqlite.assert_called_with(["English"], ["data_type"]) mock_copy.assert_called() - @patch('scribe_data.cli.convert.language_map') + @patch("scribe_data.cli.convert.language_map") def test_export_json_invalid_language(self, mock_language_map): mock_language_map.get.return_value = None - + with self.assertRaises(ValueError): export_json("invalid", "data_type", Path("/output"), True) - def test_convert_to_sqlite_no_language(self): with self.assertRaises(ValueError): convert_to_sqlite(None, "data_type", "/output", True) diff --git a/tests/cli/test_utils.py b/tests/cli/test_utils.py new file mode 100644 index 00000000..34b4cc47 --- /dev/null +++ b/tests/cli/test_utils.py @@ -0,0 +1,164 @@ +""" +Tests for the CLI utils functionality. + +.. raw:: html + +""" + +from unittest import TestCase +from unittest.mock import patch + +from scribe_data.cli.cli_utils import ( + correct_data_type, + print_formatted_data, +) + + +class TestCLIUtils(TestCase): + def test_correct_data_type(self): + self.assertEqual(correct_data_type("autosuggestion"), "autosuggestions") + self.assertEqual(correct_data_type("emoji_keyword"), "emoji_keywords") + self.assertEqual(correct_data_type("preposition"), "prepositions") + self.assertEqual(correct_data_type("translation"), "translations") + self.assertEqual(correct_data_type("invalid"), None) + + def test_correct_data_type_with_trailing_s(self): + self.assertEqual(correct_data_type("autosuggestions"), "autosuggestions") + self.assertEqual(correct_data_type("emoji_keywords"), "emoji_keywords") + self.assertEqual(correct_data_type("prepositions"), "prepositions") + self.assertEqual(correct_data_type("translations"), "translations") + + def test_correct_data_type_invalid_input(self): + self.assertIsNone(correct_data_type("invalid_data_type")) + self.assertIsNone(correct_data_type("")) + self.assertIsNone(correct_data_type(None)) + + @patch("builtins.print") + def test_print_formatted_data_autosuggestions(self, mock_print): + data = {"key1": ["value1", "value2"], "key2": ["value3"]} + print_formatted_data(data, "autosuggestions") + mock_print.assert_any_call("key1 : value1, value2") + mock_print.assert_any_call("key2 : value3") + + @patch("builtins.print") + def test_print_formatted_data_emoji_keywords(self, mock_print): + data = {"key1": [{"emoji": "😀"}, {"emoji": "😁"}], "key2": [{"emoji": "😂"}]} + print_formatted_data(data, "emoji_keywords") + mock_print.assert_any_call("key1 : 😀 😁") + mock_print.assert_any_call("key2 : 😂") + + @patch("builtins.print") + def test_print_formatted_data_prepositions_translations(self, mock_print): + data = {"key1": "value1", "key2": "value2"} + print_formatted_data(data, "prepositions") + mock_print.assert_any_call("key1 : value1") + mock_print.assert_any_call("key2 : value2") + + print_formatted_data(data, "translations") + mock_print.assert_any_call("key1 : value1") + mock_print.assert_any_call("key2 : value2") + + @patch("builtins.print") + def test_print_formatted_data_dict(self, mock_print): + data = { + "key1": {"subkey1": "value1", "subkey2": "value2"}, + "key2": ["item1", "item2"], + } + print_formatted_data(data, "dict_data") + mock_print.assert_any_call("key1 : ") + mock_print.assert_any_call(" subkey1 : value1") + mock_print.assert_any_call(" subkey2 : value2") + mock_print.assert_any_call("key2 : ") + mock_print.assert_any_call(" item1") + mock_print.assert_any_call(" item2") + + @patch("builtins.print") + def test_print_formatted_data_empty_data(self, mock_print): + print_formatted_data({}, "autosuggestions") + mock_print.assert_called_once_with( + "No data available for data type 'autosuggestions'." + ) + + @patch("builtins.print") + def test_print_formatted_data_invalid_data_type(self, mock_print): + data = {"key1": "value1", "key2": "value2"} + print_formatted_data(data, "invalid_data_type") + mock_print.assert_any_call("key1 : value1") + mock_print.assert_any_call("key2 : value2") + + @patch("builtins.print") + def test_print_formatted_data_list(self, mock_print): + data = ["item1", "item2", "item3"] + print_formatted_data(data, "list_data") + mock_print.assert_any_call("item1") + mock_print.assert_any_call("item2") + mock_print.assert_any_call("item3") + + @patch("builtins.print") + def test_print_formatted_data_list_of_dicts(self, mock_print): + data = [{"key1": "value1"}, {"key2": "value2"}] + print_formatted_data(data, "list_of_dicts") + mock_print.assert_any_call("key1 : value1") + mock_print.assert_any_call("key2 : value2") + + @patch("builtins.print") + def test_print_formatted_data_autosuggestions_redefined(self, mock_print): + data = {"key1": ["value1", "value2"], "key2": ["value3"]} + print_formatted_data(data, "autosuggestions") + + def test_print_formatted_data_autosuggestions_with_patch(self): + data = {"key1": ["value1", "value2"], "key2": ["value3", "value4"]} + with patch("builtins.print") as mock_print: + print_formatted_data(data, "autosuggestions") + mock_print.assert_any_call("key1 : value1, value2") + mock_print.assert_any_call("key2 : value3, value4") + + def test_print_formatted_data_prepositions(self): + data = {"key1": "value1", "key2": "value2"} + with patch("builtins.print") as mock_print: + print_formatted_data(data, "prepositions") + mock_print.assert_any_call("key1 : value1") + mock_print.assert_any_call("key2 : value2") + + def test_print_formatted_data_translations(self): + data = {"key1": "value1", "key2": "value2"} + with patch("builtins.print") as mock_print: + print_formatted_data(data, "translations") + mock_print.assert_any_call("key1 : value1") + mock_print.assert_any_call("key2 : value2") + + def test_print_formatted_data_nested_dict(self): + data = {"key1": {"subkey1": "subvalue1", "subkey2": "subvalue2"}} + with patch("builtins.print") as mock_print: + print_formatted_data(data, "nested_dict") + mock_print.assert_any_call("key1 : ") + mock_print.assert_any_call(" subkey1 : subvalue1") + mock_print.assert_any_call(" subkey2 : subvalue2") + + def test_print_formatted_data_list_of_dicts_with_different_keys(self): + data = [{"key1": "value1"}, {"key2": "value2"}] + with patch("builtins.print") as mock_print: + print_formatted_data(data, "list_of_dicts_different_keys") + mock_print.assert_any_call("key1 : value1") + mock_print.assert_any_call("key2 : value2") + + def test_print_formatted_data_unknown_type(self): + data = "unknown data type" + with patch("builtins.print") as mock_print: + print_formatted_data(data, "unknown") + mock_print.assert_called_once_with("unknown data type") From 7c8c5ea2cd4a32bb8cd45f7ad0fe861c214f583b Mon Sep 17 00:00:00 2001 From: Andrew Tavis McAllister Date: Fri, 30 Aug 2024 12:01:48 +0200 Subject: [PATCH 2/2] Format CLI testing code --- tests/cli/test_convert.py | 5 +- tests/cli/test_get.py | 36 +++++++++---- tests/cli/test_list.py | 110 ++++++++++++++++++++------------------ tests/cli/test_total.py | 108 ++++++++++++++++++------------------- 4 files changed, 140 insertions(+), 119 deletions(-) diff --git a/tests/cli/test_convert.py b/tests/cli/test_convert.py index 520af3e6..a98cd31c 100644 --- a/tests/cli/test_convert.py +++ b/tests/cli/test_convert.py @@ -21,9 +21,10 @@ """ import unittest -from unittest.mock import patch from pathlib import Path -from scribe_data.cli.convert import export_json, convert_to_sqlite +from unittest.mock import patch + +from scribe_data.cli.convert import convert_to_sqlite, export_json class TestConvert(unittest.TestCase): diff --git a/tests/cli/test_get.py b/tests/cli/test_get.py index 4bd09b5b..0f751cce 100644 --- a/tests/cli/test_get.py +++ b/tests/cli/test_get.py @@ -21,24 +21,38 @@ """ import unittest -from unittest.mock import patch, call +from unittest.mock import call, patch + from scribe_data.cli.get import get_data + class TestCLIGetCommand(unittest.TestCase): - @patch('scribe_data.cli.get.query_data') - @patch('scribe_data.cli.get.export_json') - @patch('scribe_data.cli.get.convert_to_csv_or_tsv') - @patch('os.system') - def test_get_command(self, mock_system, mock_convert, mock_export_json, mock_query_data): + @patch("scribe_data.cli.get.query_data") + @patch("scribe_data.cli.get.export_json") + @patch("scribe_data.cli.get.convert_to_csv_or_tsv") + @patch("os.system") + def test_get_command( + self, mock_system, mock_convert, mock_export_json, mock_query_data + ): expected_calls = [ - call(['English'], ['nouns']), - call(['English'], ['nouns']), - call() + call(["English"], ["nouns"]), + call(["English"], ["nouns"]), + call(), ] # Execute the test - get_data(language='English', data_type='nouns', output_dir='outputs', output_type='json') - get_data(language='English', data_type='nouns', output_dir='outputs', output_type='csv') + get_data( + language="English", + data_type="nouns", + output_dir="outputs", + output_type="json", + ) + get_data( + language="English", + data_type="nouns", + output_dir="outputs", + output_type="csv", + ) get_data(all=True) # Validate the calls diff --git a/tests/cli/test_list.py b/tests/cli/test_list.py index 8fa2f5c9..a89f50bf 100644 --- a/tests/cli/test_list.py +++ b/tests/cli/test_list.py @@ -21,33 +21,35 @@ """ import unittest -from unittest.mock import patch, call +from unittest.mock import call, patch + from scribe_data.cli.list import ( - list_languages, - list_data_types, list_all, + list_data_types, + list_languages, list_languages_for_data_type, list_wrapper, ) from scribe_data.cli.main import main + class TestListFunctions(unittest.TestCase): @patch("builtins.print") def test_list_languages(self, mock_print): list_languages() expected_calls = [ call(), - call('Language ISO QID '), - call('-----------------------'), - call('English en Q1860 '), - call('French fr Q150 '), - call('German de Q188 '), - call('Italian it Q652 '), - call('Portuguese pt Q5146 '), - call('Russian ru Q7737 '), - call('Spanish es Q1321 '), - call('Swedish sv Q9027 '), - call('-----------------------'), + call("Language ISO QID "), + call("-----------------------"), + call("English en Q1860 "), + call("French fr Q150 "), + call("German de Q188 "), + call("Italian it Q652 "), + call("Portuguese pt Q5146 "), + call("Russian ru Q7737 "), + call("Spanish es Q1321 "), + call("Swedish sv Q9027 "), + call("-----------------------"), call(), ] mock_print.assert_has_calls(expected_calls) @@ -57,14 +59,14 @@ def test_list_data_types_all_languages(self, mock_print): list_data_types() expected_calls = [ call(), - call('Available data types: All languages'), - call('-----------------------------------'), - call('emoji-keywords'), - call('nouns'), - call('prepositions'), - call('translations'), - call('verbs'), - call('-----------------------------------'), + call("Available data types: All languages"), + call("-----------------------------------"), + call("emoji-keywords"), + call("nouns"), + call("prepositions"), + call("translations"), + call("verbs"), + call("-----------------------------------"), call(), ] mock_print.assert_has_calls(expected_calls) @@ -74,13 +76,13 @@ def test_list_data_types_specific_language(self, mock_print): list_data_types("English") expected_calls = [ call(), - call('Available data types: English'), - call('-----------------------------'), - call('emoji-keywords'), - call('nouns'), - call('translations'), - call('verbs'), - call('-----------------------------'), + call("Available data types: English"), + call("-----------------------------"), + call("emoji-keywords"), + call("nouns"), + call("translations"), + call("verbs"), + call("-----------------------------"), call(), ] mock_print.assert_has_calls(expected_calls) @@ -91,7 +93,7 @@ def test_list_data_types_invalid_language(self): def test_list_data_types_no_data_types(self): with self.assertRaises(ValueError): - list_data_types("Klingon") + list_data_types("Klingon") @patch("scribe_data.cli.list.list_languages") @patch("scribe_data.cli.list.list_data_types") @@ -118,10 +120,14 @@ def test_list_wrapper_data_types(self, mock_list_data_types): @patch("builtins.print") def test_list_wrapper_language_and_data_type(self, mock_print): list_wrapper(language=True, data_type=True) - mock_print.assert_called_with("Please specify either a language or a data type.") + mock_print.assert_called_with( + "Please specify either a language or a data type." + ) @patch("scribe_data.cli.list.list_languages_for_data_type") - def test_list_wrapper_languages_for_data_type(self, mock_list_languages_for_data_type): + def test_list_wrapper_languages_for_data_type( + self, mock_list_languages_for_data_type + ): list_wrapper(language=True, data_type="example_data_type") mock_list_languages_for_data_type.assert_called_with("example_data_type") @@ -135,38 +141,38 @@ def test_list_languages_for_data_type_valid(self, mock_print): list_languages_for_data_type("nouns") expected_calls = [ call(), - call('Available languages: nouns'), - call('--------------------------'), - call('English'), - call('French'), - call('German'), - call('Italian'), - call('Portuguese'), - call('Russian'), - call('Spanish'), - call('Swedish'), - call('--------------------------'), + call("Available languages: nouns"), + call("--------------------------"), + call("English"), + call("French"), + call("German"), + call("Italian"), + call("Portuguese"), + call("Russian"), + call("Spanish"), + call("Swedish"), + call("--------------------------"), call(), ] mock_print.assert_has_calls(expected_calls) - @patch('scribe_data.cli.list.list_languages') + @patch("scribe_data.cli.list.list_languages") def test_list_languages_command(self, mock_list_languages): - test_args = ['main.py', 'list', '--language'] - with patch('sys.argv', test_args): + test_args = ["main.py", "list", "--language"] + with patch("sys.argv", test_args): main() mock_list_languages.assert_called_once() - @patch('scribe_data.cli.list.list_data_types') + @patch("scribe_data.cli.list.list_data_types") def test_list_data_types_command(self, mock_list_data_types): - test_args = ['main.py', 'list', '--data-type'] - with patch('sys.argv', test_args): + test_args = ["main.py", "list", "--data-type"] + with patch("sys.argv", test_args): main() mock_list_data_types.assert_called_once() - @patch('scribe_data.cli.list.list_all') + @patch("scribe_data.cli.list.list_all") def test_list_all_command(self, mock_list_all): - test_args = ['main.py', 'list', '--all'] - with patch('sys.argv', test_args): + test_args = ["main.py", "list", "--all"] + with patch("sys.argv", test_args): main() mock_list_all.assert_called_once() diff --git a/tests/cli/test_total.py b/tests/cli/test_total.py index ee7cdc64..fa9ecf6c 100644 --- a/tests/cli/test_total.py +++ b/tests/cli/test_total.py @@ -21,107 +21,107 @@ """ import unittest -from unittest.mock import patch, MagicMock, call +from unittest.mock import MagicMock, call, patch + from scribe_data.cli.total import get_total_lexemes + class TestTotalLexemes(unittest.TestCase): - @patch('scribe_data.cli.total.get_qid_by_input') - @patch('scribe_data.cli.total.sparql.query') + @patch("scribe_data.cli.total.get_qid_by_input") + @patch("scribe_data.cli.total.sparql.query") def test_get_total_lexemes_valid(self, mock_query, mock_get_qid): - mock_get_qid.side_effect = lambda x: {'english': 'Q1860', 'nouns': 'Q1084'}.get(x.lower(), None) + mock_get_qid.side_effect = lambda x: {"english": "Q1860", "nouns": "Q1084"}.get( + x.lower(), None + ) mock_results = MagicMock() mock_results.convert.return_value = { - "results": { - "bindings": [ - {"total": {"value": "42"}} - ] - } + "results": {"bindings": [{"total": {"value": "42"}}]} } mock_query.return_value = mock_results - with patch('builtins.print') as mock_print: - get_total_lexemes('English', 'nouns') + with patch("builtins.print") as mock_print: + get_total_lexemes("English", "nouns") - mock_print.assert_called_once_with('Language: English\nData type: nouns\nTotal number of lexemes: 42') + mock_print.assert_called_once_with( + "Language: English\nData type: nouns\nTotal number of lexemes: 42" + ) - @patch('scribe_data.cli.total.get_qid_by_input') - @patch('scribe_data.cli.total.sparql.query') + @patch("scribe_data.cli.total.get_qid_by_input") + @patch("scribe_data.cli.total.sparql.query") def test_get_total_lexemes_no_results(self, mock_query, mock_get_qid): - mock_get_qid.side_effect = lambda x: {'english': 'Q1860', 'nouns': 'Q1084'}.get(x.lower(), None) + mock_get_qid.side_effect = lambda x: {"english": "Q1860", "nouns": "Q1084"}.get( + x.lower() + ) mock_results = MagicMock() - mock_results.convert.return_value = { - "results": { - "bindings": [] - } - } + mock_results.convert.return_value = {"results": {"bindings": []}} mock_query.return_value = mock_results - with patch('builtins.print') as mock_print: - get_total_lexemes('English', 'nouns') + with patch("builtins.print") as mock_print: + get_total_lexemes("English", "nouns") - mock_print.assert_called_once_with('Total number of lexemes: Not found') + mock_print.assert_called_once_with("Total number of lexemes: Not found") - @patch('scribe_data.cli.total.get_qid_by_input') - @patch('scribe_data.cli.total.sparql.query') + @patch("scribe_data.cli.total.get_qid_by_input") + @patch("scribe_data.cli.total.sparql.query") def test_get_total_lexemes_invalid_language(self, mock_query, mock_get_qid): mock_get_qid.side_effect = lambda x: None mock_query.return_value = MagicMock() - with patch('builtins.print') as mock_print: - get_total_lexemes('InvalidLanguage', 'nouns') + with patch("builtins.print") as mock_print: + get_total_lexemes("InvalidLanguage", "nouns") - mock_print.assert_called_once_with('Total number of lexemes: Not found') + mock_print.assert_called_once_with("Total number of lexemes: Not found") - @patch('scribe_data.cli.total.get_qid_by_input') - @patch('scribe_data.cli.total.sparql.query') + @patch("scribe_data.cli.total.get_qid_by_input") + @patch("scribe_data.cli.total.sparql.query") def test_get_total_lexemes_empty_and_none_inputs(self, mock_query, mock_get_qid): mock_get_qid.return_value = None mock_query.return_value = MagicMock() # Call the function with empty and None inputs - with patch('builtins.print') as mock_print: - get_total_lexemes('', 'nouns') - get_total_lexemes(None, 'verbs') + with patch("builtins.print") as mock_print: + get_total_lexemes("", "nouns") + get_total_lexemes(None, "verbs") expected_calls = [ - call('Total number of lexemes: Not found'), - call('Total number of lexemes: Not found') + call("Total number of lexemes: Not found"), + call("Total number of lexemes: Not found"), ] mock_print.assert_has_calls(expected_calls, any_order=True) - @patch('scribe_data.cli.total.get_qid_by_input') - @patch('scribe_data.cli.total.sparql.query') + @patch("scribe_data.cli.total.get_qid_by_input") + @patch("scribe_data.cli.total.sparql.query") def test_get_total_lexemes_nonexistent_language(self, mock_query, mock_get_qid): mock_get_qid.return_value = None mock_query.return_value = MagicMock() - with patch('builtins.print') as mock_print: - get_total_lexemes('Martian', 'nouns') + with patch("builtins.print") as mock_print: + get_total_lexemes("Martian", "nouns") + + mock_print.assert_called_once_with("Total number of lexemes: Not found") - mock_print.assert_called_once_with('Total number of lexemes: Not found') - - @patch('scribe_data.cli.total.get_qid_by_input') - @patch('scribe_data.cli.total.sparql.query') + @patch("scribe_data.cli.total.get_qid_by_input") + @patch("scribe_data.cli.total.sparql.query") def test_get_total_lexemes_various_data_types(self, mock_query, mock_get_qid): - mock_get_qid.side_effect = lambda x: {'english': 'Q1860', 'verbs': 'Q24905', 'nouns': 'Q1084'}.get(x.lower(), None) + mock_get_qid.side_effect = lambda x: { + "english": "Q1860", + "verbs": "Q24905", + "nouns": "Q1084", + }.get(x.lower()) mock_results = MagicMock() mock_results.convert.return_value = { - "results": { - "bindings": [ - {"total": {"value": "30"}} - ] - } + "results": {"bindings": [{"total": {"value": "30"}}]} } mock_query.return_value = mock_results # Call the function with different data types - with patch('builtins.print') as mock_print: - get_total_lexemes('English', 'verbs') - get_total_lexemes('English', 'nouns') + with patch("builtins.print") as mock_print: + get_total_lexemes("English", "verbs") + get_total_lexemes("English", "nouns") expected_calls = [ - call('Language: English\nData type: verbs\nTotal number of lexemes: 30'), - call('Language: English\nData type: nouns\nTotal number of lexemes: 30') + call("Language: English\nData type: verbs\nTotal number of lexemes: 30"), + call("Language: English\nData type: nouns\nTotal number of lexemes: 30"), ] mock_print.assert_has_calls(expected_calls)