def setUp(self):
template = PicklableMock()
template.get_template = Mock(return_value=[])
user = PicklableMock()
user.parametrizer = MockParametrizer(user, {})
user.message = PicklableMock()
user.person_info = PicklableMock()
user.descriptions = {"render_templates": template}
self.user = user
def test_scenario_action_without_jinja(self):
action = RunScenarioAction({"scenario": "next_scenario"})
user = PicklableMock()
user.parametrizer = MockParametrizer(user, {})
scen = PicklableMock()
scen_result = 'done'
scen.run.return_value = scen_result
user.descriptions = {"scenarios": {"next_scenario": scen}}
result = action.run(user, PicklableMock())
self.assertEqual(result, scen_result)
def mock_and_perform_action(
test_items: Dict[str, Any],
expected_result: Optional[str] = None,
expected_scen: Optional[str] = None) -> Union[str, None]:
action = ChoiceScenarioAction(test_items)
user = PicklableMock()
user.parametrizer = MockParametrizer(user, {})
scen = PicklableMock()
scen.run.return_value = expected_result
if expected_scen:
user.descriptions = {"scenarios": {expected_scen: scen}}
return action.run(user, PicklableMock())
def test_expire(self):
user = PicklableMock()
user.forms = {"pay_phone_scenario": None}
pay_phone_scenario = PicklableMock()
pay_phone_scenario.form_type = "pay_phone_scenario"
scenarios = ScenarioDescription({"pay_phone_scenario": pay_phone_scenario})
user.descriptions = {"scenarios": scenarios}
last_scenario_description = PicklableMock()
items = ["pay_phone_scenario"]
ls = LastScenarios(items, last_scenario_description, user)
ls.expire()
self.assertSequenceEqual([], ls.raw)
def test_scenario_action(self):
action = RunLastScenarioAction({})
user = PicklableMock()
scen = PicklableMock()
scen_result = 'done'
scen.run.return_value = scen_result
user.descriptions = {"scenarios": {"test": scen}}
user.last_scenarios = PicklableMock()
last_scenario_name = "test"
user.last_scenarios.scenarios_names = [last_scenario_name]
user.last_scenarios.last_scenario_name = last_scenario_name
result = action.run(user, PicklableMock())
self.assertEqual(result, scen_result)
def test_scenario_action_with_jinja_good(self):
params = {'next_scenario': 'ANNA.pipeline.scenario'}
items = {"scenario": "{{next_scenario}}"}
action = RunScenarioAction(items)
user = PicklableMock()
user.parametrizer = MockParametrizer(user, {"data": params})
scen = PicklableMock()
scen_result = 'done'
scen.run.return_value = scen_result
user.descriptions = {"scenarios": {"ANNA.pipeline.scenario": scen}}
result = action.run(user, PicklableMock())
self.assertEqual(result, scen_result)
def test_action(self):
scenario_name = "test_scenario"
user = PicklableMock()
user.forms = PicklableMock()
user.last_scenarios.last_scenario_name = scenario_name
scenario = PicklableMock()
scenario.form_type = scenario_name
user.descriptions = {"scenarios": {scenario_name: scenario}}
action = ClearScenarioByIdAction({"scenario_id": scenario_name})
result = action.run(user, {}, {})
self.assertIsNone(result)
user.last_scenarios.delete.assert_called_once()
user.forms.remove_item.assert_called_once()
def test_action_with_empty_last_scenario(self):
scenario_name = "test_scenario"
user = PicklableMock()
user.forms = PicklableMock()
user.forms.remove_item = PicklableMock()
user.last_scenarios.last_scenario_name = None
scenario = PicklableMock()
scenario.form_type = scenario_name
scenario.keep_forms_alive = False
user.descriptions = {"scenarios": {scenario_name: scenario}}
action = ClearCurrentScenarioFormAction({})
result = action.run(user, {}, {})
self.assertIsNone(result)
user.forms.remove_item.assert_not_called()
def test_1(self):
expected = 5
items = {"filler": "my_key"}
mock_filler = PicklableMock()
mock_filler.run = Mock(return_value=expected)
mock_user = PicklableMock()
mock_user.descriptions = {
"external_field_fillers": {
"my_key": mock_filler
}
}
filler = ExternalFieldFillerDescription(items)
result = filler.extract(None, mock_user)
self.assertEqual(expected, result)
def test_classifier_requirement_false(self, mock_classifier_model):
"""Тест кейз проверяет что условие возвращает False, если модель классификации не вернула ответ."""
test_items = {
"type": "classifier",
"classifier": {
"type": "external",
"classifier": "hello_scenario_classifier"
}
}
classifier_requirement = ClassifierRequirement(test_items)
mock_user = PicklableMock()
mock_user.descriptions = {
"external_classifiers":
["read_book_or_not_classifier", "hello_scenario_classifier"]
}
result = classifier_requirement.check(PicklableMock(), mock_user)
self.assertFalse(result)
def test_clear_form(self):
expected_result = {
'sbm_credit': {
'fields': {
'amount': {
'value': 100.0
},
'currency': {
'filler': {
'type': 'currency_first'
},
'questions': [{
'action': 'sbm_currency_question',
'type': 'external'
}],
'required':
True
}
},
'remove_time': 1506418333
}
}
description_MB = MockDescription('Turn_on_MB', False)
description_credit = MockDescription('sbm_credit', False)
description_off_MB = MockDescription('Turn_off_MB', False)
descriptions = {
"scenarios":
MockDescriptions({
'Turn_on_MB': description_MB,
'sbm_credit': description_credit,
'Turn_off_MB': description_off_MB
}),
"forms":
MockDescriptions({
'Turn_on_MB': description_MB,
'sbm_credit': description_credit,
'Turn_off_MB': description_off_MB
})
}
user = PicklableMock()
user.descriptions = descriptions
forms = Forms(self.mock_1, descriptions["forms"], user)
user.forms = forms
forms.clear_form("Turn_on_MB")
self.assertEqual(expected_result, user.forms.raw)
def test_classifier_requirement_false_if_class_other(
self, mock_classifier_model):
"""Тест кейз проверяет что условие возвращает False, если наиболее вероятный вариант есть класс other."""
test_items = {
"type": "classifier",
"classifier": {
"type": "external",
"classifier": "hello_scenario_classifier"
}
}
classifier_requirement = ClassifierRequirement(test_items)
mock_user = PicklableMock()
mock_user.descriptions = {
"external_classifiers":
["read_book_or_not_classifier", "hello_scenario_classifier"]
}
result = classifier_requirement.check(PicklableMock(), mock_user)
self.assertFalse(result)
def test_add_1(self):
items = ["pay_phone_scenario"]
forms = MagicMock(name="context_form_mock")
forms.clear_form = self.remove_item
user = PicklableMock()
user.forms = forms
pay_phone_scenario = PicklableMock()
pay_phone_scenario.keep_forms_alive = False
pay_phone_scenario.form_type = "pay_phone_scenario"
user.descriptions = {"scenarios": ScenarioDescription({"pay_phone_scenario": pay_phone_scenario})}
last_scenario_description = PicklableMock()
last_scenario_description.get_count = Mock(return_value=1)
ls = LastScenarios(items, last_scenario_description, user)
new_scenario = "callcenter_scenario"
ls.add(new_scenario, None)
self.assertSequenceEqual(["callcenter_scenario"], ls.raw)
self.assertSequenceEqual({"callcenter_scenario": {"remove_time": 2506421370}}, self.forms_dict)
def test_clear_all(self):
items = ["pay_phone_scenario"]
forms = MagicMock(name="context_form_mock")
user = PicklableMock()
user.forms = forms
pay_phone_scenario = PicklableMock()
pay_phone_scenario.keep_forms_alive = False
user.descriptions = {"scenarios": {"pay_phone_scenario": pay_phone_scenario}}
last_scenario_description = PicklableMock()
last_scenario_description.check = Mock(return_value=True)
last_scenario_description.get_count = Mock(return_value=2)
ls = LastScenarios(items, last_scenario_description, user)
new_scenario = "callcenter_scenario"
ls.add(new_scenario, None)
ls.clear_all()
self.assertSequenceEqual([], ls.raw)
def test_classifier_requirement_true(self, mock_classifier_model):
"""Тест кейз проверяет что условие возвращает True, если результат классификации запроса относится к одной
из указанных категорий, прошедших порог, но не равной классу other.
"""
test_items = {
"type": "classifier",
"classifier": {
"type": "external",
"classifier": "hello_scenario_classifier"
}
}
classifier_requirement = ClassifierRequirement(test_items)
mock_user = PicklableMock()
mock_user.descriptions = {
"external_classifiers":
["read_book_or_not_classifier", "hello_scenario_classifier"]
}
result = classifier_requirement.check(PicklableMock(), mock_user)
self.assertTrue(result)
def test_add_2(self):
items = ["pay_phone_scenario"]
forms = MagicMock(name="context_form_mock")
user = PicklableMock()
user.forms = forms
pay_phone_scenario = PicklableMock()
pay_phone_scenario.keep_forms_alive = False
user.descriptions = {"scenarios": {"pay_phone_scenario": pay_phone_scenario}}
last_scenario_description = PicklableMock()
last_scenario_description.get_count = Mock(return_value=2)
ls = LastScenarios(items, last_scenario_description, user)
new_scenario = "callcenter_scenario"
ls.add(new_scenario, None)
self.assertSequenceEqual(["pay_phone_scenario", "callcenter_scenario"], ls.raw)
self.assertSequenceEqual({"pay_phone_scenario":
{"fields": {"amount": {"value": 100.0},
"approve": {"available": True, "value": True}},
"remove_time": 1506418333},
"callcenter_scenario": {"remove_time": 2506421370}}, self.forms_dict)
def test_add_3(self):
items = ["pay_phone_scenario"]
forms = MagicMock(name="context_form_mock")
user = PicklableMock()
user.forms = forms
pay_phone_scenario = PicklableMock()
pay_phone_scenario.keep_forms_alive = True
user.descriptions = {"scenarios": ScenarioDescription({"pay_phone_scenario": pay_phone_scenario})}
last_scenario_description = PicklableMock()
last_scenario_description.check = Mock(return_value=True)
last_scenario_description.get_count = Mock(return_value=1)
ls = LastScenarios(items, last_scenario_description, user)
new_scenario = "callcenter_scenario"
ls.add(new_scenario, None)
correct_result = {'pay_phone_scenario': {'fields': {'amount': {'value': 100.0}, 'approve': {'available': True,
'value': True}},
'remove_time': 1506418333}, 'callcenter_scenario': {'remove_time': 2506421370}}
self.assertSequenceEqual(["callcenter_scenario"], ls.raw)
self.assertSequenceEqual(correct_result, self.forms_dict)
