Spaces:
Build error
Build error
Validify-testbot-1
/
botbuilder-python
/libraries
/botbuilder-dialogs
/tests
/choices
/test_choice_recognizers.py
| # Copyright (c) Microsoft Corporation. All rights reserved. | |
| # Licensed under the MIT License. | |
| from typing import List | |
| import aiounittest | |
| from botbuilder.dialogs.choices import ( | |
| ChoiceRecognizers, | |
| Find, | |
| FindValuesOptions, | |
| SortedValue, | |
| ) | |
| def assert_result(result, start, end, text): | |
| assert ( | |
| result.start == start | |
| ), f"Invalid ModelResult.start of '{result.start}' for '{text}' result." | |
| assert ( | |
| result.end == end | |
| ), f"Invalid ModelResult.end of '{result.end}' for '{text}' result." | |
| assert ( | |
| result.text == text | |
| ), f"Invalid ModelResult.text of '{result.text}' for '{text}' result." | |
| def assert_value(result, value, index, score): | |
| assert ( | |
| result.type_name == "value" | |
| ), f"Invalid ModelResult.type_name of '{result.type_name}' for '{value}' value." | |
| assert result.resolution, f"Missing ModelResult.resolution for '{value}' value." | |
| resolution = result.resolution | |
| assert ( | |
| resolution.value == value | |
| ), f"Invalid resolution.value of '{resolution.value}' for '{value}' value." | |
| assert ( | |
| resolution.index == index | |
| ), f"Invalid resolution.index of '{resolution.index}' for '{value}' value." | |
| assert ( | |
| resolution.score == score | |
| ), f"Invalid resolution.score of '{resolution.score}' for '{value}' value." | |
| def assert_choice(result, value, index, score, synonym=None): | |
| assert ( | |
| result.type_name == "choice" | |
| ), f"Invalid ModelResult.type_name of '{result.type_name}' for '{value}' choice." | |
| assert result.resolution, f"Missing ModelResult.resolution for '{value}' choice." | |
| resolution = result.resolution | |
| assert ( | |
| resolution.value == value | |
| ), f"Invalid resolution.value of '{resolution.value}' for '{value}' choice." | |
| assert ( | |
| resolution.index == index | |
| ), f"Invalid resolution.index of '{resolution.index}' for '{value}' choice." | |
| assert ( | |
| resolution.score == score | |
| ), f"Invalid resolution.score of '{resolution.score}' for '{value}' choice." | |
| if synonym: | |
| assert ( # pylint: disable=assert-on-tuple | |
| resolution.synonym == synonym, | |
| f"Invalid resolution.synonym of '{resolution.synonym}' for '{value}' choice.", | |
| ) | |
| _color_choices: List[str] = ["red", "green", "blue"] | |
| _overlapping_choices: List[str] = ["bread", "bread pudding", "pudding"] | |
| _color_values: List[SortedValue] = [ | |
| SortedValue(value="red", index=0), | |
| SortedValue(value="green", index=1), | |
| SortedValue(value="blue", index=2), | |
| ] | |
| _overlapping_values: List[SortedValue] = [ | |
| SortedValue(value="bread", index=0), | |
| SortedValue(value="bread pudding", index=1), | |
| SortedValue(value="pudding", index=2), | |
| ] | |
| _similar_values: List[SortedValue] = [ | |
| SortedValue(value="option A", index=0), | |
| SortedValue(value="option B", index=1), | |
| SortedValue(value="option C", index=2), | |
| ] | |
| class ChoiceRecognizersTest(aiounittest.AsyncTestCase): | |
| # Find.find_values | |
| def test_should_find_a_simple_value_in_a_single_word_utterance(self): | |
| found = Find.find_values("red", _color_values) | |
| assert len(found) == 1, f"Invalid token count of '{len(found)}' returned." | |
| assert_result(found[0], 0, 2, "red") | |
| assert_value(found[0], "red", 0, 1.0) | |
| def test_should_find_a_simple_value_in_an_utterance(self): | |
| found = Find.find_values("the red one please.", _color_values) | |
| assert len(found) == 1, f"Invalid token count of '{len(found)}' returned." | |
| assert_result(found[0], 4, 6, "red") | |
| assert_value(found[0], "red", 0, 1.0) | |
| def test_should_find_multiple_values_within_an_utterance(self): | |
| found = Find.find_values("the red and blue ones please.", _color_values) | |
| assert len(found) == 2, f"Invalid token count of '{len(found)}' returned." | |
| assert_result(found[0], 4, 6, "red") | |
| assert_value(found[0], "red", 0, 1.0) | |
| assert_value(found[1], "blue", 2, 1.0) | |
| def test_should_find_multiple_values_that_overlap(self): | |
| found = Find.find_values( | |
| "the bread pudding and bread please.", _overlapping_values | |
| ) | |
| assert len(found) == 2, f"Invalid token count of '{len(found)}' returned." | |
| assert_result(found[0], 4, 16, "bread pudding") | |
| assert_value(found[0], "bread pudding", 1, 1.0) | |
| assert_value(found[1], "bread", 0, 1.0) | |
| def test_should_correctly_disambiguate_between_similar_values(self): | |
| found = Find.find_values( | |
| "option B", _similar_values, FindValuesOptions(allow_partial_matches=True) | |
| ) | |
| assert len(found) == 1, f"Invalid token count of '{len(found)}' returned." | |
| assert_value(found[0], "option B", 1, 1.0) | |
| def test_should_find_a_single_choice_in_an_utterance(self): | |
| found = Find.find_choices("the red one please.", _color_choices) | |
| assert len(found) == 1, f"Invalid token count of '{len(found)}' returned." | |
| assert_result(found[0], 4, 6, "red") | |
| assert_choice(found[0], "red", 0, 1.0, "red") | |
| def test_should_find_multiple_choices_within_an_utterance(self): | |
| found = Find.find_choices("the red and blue ones please.", _color_choices) | |
| assert len(found) == 2, f"Invalid token count of '{len(found)}' returned." | |
| assert_result(found[0], 4, 6, "red") | |
| assert_choice(found[0], "red", 0, 1.0) | |
| assert_choice(found[1], "blue", 2, 1.0) | |
| def test_should_find_multiple_choices_that_overlap(self): | |
| found = Find.find_choices( | |
| "the bread pudding and bread please.", _overlapping_choices | |
| ) | |
| assert len(found) == 2, f"Invalid token count of '{len(found)}' returned." | |
| assert_result(found[0], 4, 16, "bread pudding") | |
| assert_choice(found[0], "bread pudding", 1, 1.0) | |
| assert_choice(found[1], "bread", 0, 1.0) | |
| def test_should_accept_null_utterance_in_find_choices(self): | |
| found = Find.find_choices(None, _color_choices) | |
| assert not found | |
| # ChoiceRecognizers.recognize_choices | |
| def test_should_find_a_choice_in_an_utterance_by_name(self): | |
| found = ChoiceRecognizers.recognize_choices( | |
| "the red one please.", _color_choices | |
| ) | |
| assert len(found) == 1 | |
| assert_result(found[0], 4, 6, "red") | |
| assert_choice(found[0], "red", 0, 1.0, "red") | |
| def test_should_find_a_choice_in_an_utterance_by_ordinal_position(self): | |
| found = ChoiceRecognizers.recognize_choices( | |
| "the first one please.", _color_choices | |
| ) | |
| assert len(found) == 1 | |
| assert_result(found[0], 4, 8, "first") | |
| assert_choice(found[0], "red", 0, 1.0) | |
| def test_should_find_multiple_choices_in_an_utterance_by_ordinal_position(self): | |
| found = ChoiceRecognizers.recognize_choices( | |
| "the first and third one please", _color_choices | |
| ) | |
| assert len(found) == 2 | |
| assert_choice(found[0], "red", 0, 1.0) | |
| assert_choice(found[1], "blue", 2, 1.0) | |
| def test_should_find_a_choice_in_an_utterance_by_numerical_index_digit(self): | |
| found = ChoiceRecognizers.recognize_choices("1", _color_choices) | |
| assert len(found) == 1 | |
| assert_result(found[0], 0, 0, "1") | |
| assert_choice(found[0], "red", 0, 1.0) | |
| def test_should_find_a_choice_in_an_utterance_by_numerical_index_text(self): | |
| found = ChoiceRecognizers.recognize_choices("one", _color_choices) | |
| assert len(found) == 1 | |
| assert_result(found[0], 0, 2, "one") | |
| assert_choice(found[0], "red", 0, 1.0) | |
| def test_should_find_multiple_choices_in_an_utterance_by_numerical_index(self): | |
| found = ChoiceRecognizers.recognize_choices("option one and 3.", _color_choices) | |
| assert len(found) == 2 | |
| assert_choice(found[0], "red", 0, 1.0) | |
| assert_choice(found[1], "blue", 2, 1.0) | |
| def test_should_accept_null_utterance_in_recognize_choices(self): | |
| found = ChoiceRecognizers.recognize_choices(None, _color_choices) | |
| assert not found | |