def setUp(self):
self.max_delay = 1
self.max_delay_s = self.max_delay * 60
self.delay_runner = DelayRunner(1)
self.run = PicklableMock()
self.arg = PicklableMock()
self.delay_runner.schedule_run(self.run, [self.arg])
class TestDelayRunner(TestCase):
def setUp(self):
self.max_delay = 1
self.max_delay_s = self.max_delay * 60
self.delay_runner = DelayRunner(1)
self.run = PicklableMock()
self.arg = PicklableMock()
self.delay_runner.schedule_run(self.run, [self.arg])
def test_set_run_time(self):
self.assertEqual(self.delay_runner._run_item, self.run)
self.assertListEqual(self.delay_runner._run_args, [self.arg])
self.assertTrue(
0 < self.delay_runner._ts - time.time() < self.max_delay_s)
def test_check_can_run(self):
self.delay_runner._ts = self.delay_runner._ts - self.max_delay_s
self.assertTrue(self.delay_runner.check_can_run())
def test_check_cant_run(self):
self.delay_runner._ts = time.time() + self.max_delay_s
self.assertFalse(self.delay_runner.check_can_run())
def test_run(self):
self.delay_runner._ts = self.delay_runner._ts - self.max_delay_s
self.delay_runner.run()
self.run.assert_called_once_with(self.arg)
self.assertLess(self.delay_runner._ts, time.time())
self.assertIsNone(self.delay_runner._run_args)
self.assertIsNone(self.delay_runner._run_item)
def test_5(self, mock_get_app_config):
patch_get_app_config(mock_get_app_config)
expected = 'дефолтный тунец'
items = {
'cases': {
'лосось': [
'хорошая рыба'
],
'килька': [
'консервы'
]
},
'default': 'дефолтный тунец'
}
text_preprocessing_result = PicklableMock()
text_preprocessing_result.tokenized_elements_list_pymorphy = [
{'lemma': 'мой'},
{'lemma': 'дядя'},
{'lemma': 'самый'},
{'lemma': 'честный'},
{'lemma': 'правило'},
]
filler = IntersectionFieldFiller(items)
result = filler.extract(text_preprocessing_result, None)
self.assertEqual(expected, result)
def setUp(self):
self.test_items1 = {
"123-ASDF": {
"behavior_id": 11,
"expire_time": time.time() + 10,
"scenario_id": 22,
"text_preprocessing_result": {},
"action_params": {}
}
}
self.test_items2 = {
"123-ASDF": {
"behavior_id": 11,
"expire_time": time.time(),
"scenario_id": 22,
"text_preprocessing_result": {},
"action_params": {}
}
}
self.test_user = Mock('User')
self.test_user.id = 111
self.test_user.message = PicklableMock()
self.test_user.message.incremental_id = 123
self.test_user.message.logging_uuid = 222
self.test_user.settings = PicklableMock()
self.test_user.settings.app_name = "test"
self.test_descriptions = Mock('Descriptions')
def setUp(self):
self.logger = PicklableMock()
self.logger.exception = PicklableMock()
self.config = PicklableMock()
self.mock_rep = PicklableMock()
self.monitoring = Monitoring()
self.monitoring.apply_config({})
def patch_get_app_config(mock_get_app_config):
result = PicklableMock()
sk_path = os.path.dirname(smart_kit.__file__)
result.STATIC_PATH = os.path.join(sk_path, 'template/static')
mock_get_app_config.return_value = result
result.NORMALIZER = LocalTextNormalizer()
mock_get_app_config.return_value = result
def test_3(self):
text_preprocessing_result = PicklableMock()
text_preprocessing_result.person_token_values = []
result = self.filler.extract(text_preprocessing_result, None)
self.assertIsNone(result)
def test_history_expire(self):
now = time()
descriptions = PicklableMock()
descriptions.event_expiration_delay = 5
items = {
'events': [{
'type': 'event_type_1',
'content': {
'foo': 'bar'
},
'created_time': now - 1
}, {
'type': 'event_type_2',
'content': {
'foo': 'bar'
},
'created_time': now - 5
}]
}
expected_keys = {
'event_type_1',
}
history = History(items, descriptions, None)
history.expire()
history_raw = history.raw
events_raw = history_raw["events"]
event_keys = {event_raw.get("type") for event_raw in events_raw}
self.assertSetEqual(event_keys, expected_keys)
def test_get_events(self):
descriptions = PicklableMock()
descriptions.formatter = HistoryEventFormatter()
items = {
'events': [{
'type': 'field_event',
'scenario': 'name',
'node': 'node',
'results': 'filled',
'content': {
'field': 'field_name'
}
}]
}
expected = [{
'no': 1,
'scenarioName': 'name',
'scenarioVersion': None,
'results': 'filled',
'eventType': 'field_event',
'eventContent': {
'field': 'field_name'
}
}]
history = History(items, descriptions, None)
events = history.get_events()
self.assertDictEqual(events[0], expected[0])
def test_raw(self):
user = PicklableMock()
forms = Forms(self.mock_1, {
"sbm_credit": PicklableMock(),
"Turn_on_MB": PicklableMock()
}, user)
expected_dict = {
'sbm_credit': {
'fields': {
'amount': {
'value': 100.0
},
'currency': {
"required":
True,
"filler": {
"type": "currency_first"
},
"questions": [{
"type": "external",
"action": "sbm_currency_question"
}]
}
},
'remove_time': 1506418333
},
'Turn_on_MB': {
'remove_time': 2506421370
}
}
self.assertDictEqual(forms.raw, expected_dict)
def test_channel_fail(self):
user = PicklableMock()
message = Mock(channel="ch2")
user.message = message
requirement = ChannelRequirement({"channels": ["ch1"]})
text_normalization_result = None
self.assertFalse(requirement.check(text_normalization_result, user))
def test_2(self, mock_get_app_config):
patch_get_app_config(mock_get_app_config)
items = {
'strict': True,
'cases': {
'лосось': [
'хорошая рыба'
],
'килька': [
'консервы'
]
}
}
text_preprocessing_result = PicklableMock()
text_preprocessing_result.tokenized_elements_list_pymorphy = [
{'lemma': 'весь'},
{'lemma': 'хороший'},
{'lemma': 'и'},
{'lemma': 'спасибо'},
{'lemma': 'за'},
{'lemma': 'рыба'},
]
filler = IntersectionFieldFiller(items)
result = filler.extract(text_preprocessing_result, None)
self.assertIsNone(result)
def test_extract_no_match(self):
text_preprocessing_result = PicklableMock()
text_preprocessing_result.original_text = "text"
filler = RegexpFieldFiller(self.items)
result = filler.extract(text_preprocessing_result, self.user)
self.assertIsNone(result)
def test_no_exp(self):
field_value = "1-RSAR09A"
text_preprocessing_result = PicklableMock()
text_preprocessing_result.original_text = field_value
filler = RegexpFieldFiller(self.items)
filler.regexp = None
self.assertIsNone(filler.extract(text_preprocessing_result, self.user))
def test_extract_no_match(self):
text_preprocessing_result = PicklableMock()
text_preprocessing_result.original_text = "текст без искомых номеров"
filler = AllRegexpsFieldFiller(self.items)
result = filler.extract(text_preprocessing_result, None)
self.assertIsNone(result)
def test_extract_2(self):
field_value = "поручение12 поручение14 #1 n3 п/п70 n33"
text_preprocessing_result = PicklableMock()
text_preprocessing_result.original_text = field_value
filler = AllRegexpsFieldFiller(self.items)
result = filler.extract(text_preprocessing_result, None)
self.assertEqual("3|33|1|12|14|70", result)
def test_extract_1(self):
field_value = "Просим отозвать платежное поручение 14 от 23.01.19 на сумму 3500 и вернуть деньги на расчетный счет."
text_preprocessing_result = PicklableMock()
text_preprocessing_result.original_text = field_value
filler = AllRegexpsFieldFiller(self.items)
result = filler.extract(text_preprocessing_result, None)
self.assertEqual('14', result)
def test_2(self):
expected = "тинькофф"
text_preprocessing_result = PicklableMock()
text_preprocessing_result.org_token_values = ["тинькофф", "втб", "мегафон"]
result = self.filler.extract(text_preprocessing_result, None)
self.assertEqual(expected, result)
def setUpClass(cls):
user = PicklableMock()
user.message = PicklableMock()
user.parametrizer = MockParametrizer(user, {})
user.last_scenarios.last_scenario_name = "scenario_id"
test_incremental_id = "test_incremental_id"
user.message.incremental_id = test_incremental_id
cls.user = user
def test_1(self):
expected = {"name": "иван"}
text_preprocessing_result = PicklableMock()
text_preprocessing_result.person_token_values = [{"name": "иван"}]
result = self.filler.extract(text_preprocessing_result, None)
self.assertDictEqual(expected, result)
def test_2(self):
expected = "москва"
text_preprocessing_result = PicklableMock()
text_preprocessing_result.geo_token_values = ["москва", "питер", "казань"]
result = self.filler.extract(text_preprocessing_result, None)
self.assertEqual(expected, result)
def test_template_req_raise(self):
items = {"template": "{{ payload.groupCode }}"}
requirement = TemplateRequirement(items)
params = {"payload": {"groupCode": "BROKER1"}}
user = PicklableMock()
user.parametrizer = PicklableMock()
user.parametrizer.collect = Mock(return_value=params)
self.assertRaises(TypeError, requirement.check, None, user)
def test_template_req_false(self):
items = {"template": "{{ payload.groupCode == 'BROKER' }}"}
requirement = TemplateRequirement(items)
params = {"payload": {"groupCode": "BROKER1"}}
user = PicklableMock()
user.parametrizer = PicklableMock()
user.parametrizer.collect = Mock(return_value=params)
self.assertFalse(requirement.check(None, user))
def test_remove(self):
user = PicklableMock()
forms = Forms(self.mock_1, {
"sbm_credit": PicklableMock(),
"Turn_on_MB": PicklableMock()
}, user)
forms.remove_item("sbm_credit")
expected_dict = {"Turn_on_MB": {'remove_time': 2506421370}}
self.assertDictEqual(forms.raw, expected_dict)
def test_clear(self):
user = PicklableMock()
items = [{"ts": 35343820800, "message": {"test": 567}, "direction": "incoming"}]
description = PicklableMock()
description.max_message_count = 1
description.lifetime = 10
preprocessing_messages = PreprocessingScenariosMessages(items, description, user)
preprocessing_messages.clear()
self.assertListEqual([item for item in preprocessing_messages.processed_items], [])
def test_extract(self):
field_value = "1-RSAR09A"
text_preprocessing_result = PicklableMock()
text_preprocessing_result.original_text = field_value
filler = RegexpFieldFiller(self.items)
result = filler.extract(text_preprocessing_result, self.user)
self.assertEqual(field_value, result)
def test_first_try_failed(self):
self.param = PicklableMock()
self.param1 = {"param1_name": PicklableMock()}
self.action = Mock(
side_effect=[HandledException(), self.expected_value])
result = self.rerunable.run(self.action, self.param, **self.param1)
self.action.assert_called_with(self.param, **self.param1)
self.assertEqual(self.action.call_count, self.try_count)
self.assertEqual(result, self.expected_value)
def test_2(self):
items = {}
text_preprocessing_result = PicklableMock()
text_preprocessing_result.ccy_token_values = []
filler = FirstCurrencyFiller(items)
result = filler.extract(text_preprocessing_result, None)
self.assertIsNone(result)
def test_run_1(self):
scenario_id = "test_id"
action = BreakScenarioAction({"scenario_id": scenario_id})
user = PicklableMock()
scenario_model = PicklableMagicMock()
scenario_model.set_break = Mock(return_value=None)
user.scenario_models = {scenario_id: scenario_model}
action.run(user, None)
user.scenario_models[scenario_id].set_break.assert_called_once()
def test_any_substring_in_lowered_text_requirement_false(self):
"""Тест кейз проверяет что условие возвращает False, т.к НЕ нашлась ни одна подстрока из списка substrings,
которая бы встречалась в оригинальном тексте в нижнем регистре.
"""
req = AnySubstringInLoweredTextRequirement(
{"substrings": ["искомая подстрока", "другая подстрока"]})
text_preprocessing_result = PicklableMock()
text_preprocessing_result.raw = {"original_text": "КАКОЙ-ТО ТЕКСТ"}
result = req.check(text_preprocessing_result, PicklableMock())
self.assertFalse(result)
