def test_type_cast_json(self): template = UnifiedTemplate({ "type": UNIFIED_TEMPLATE_TYPE_NAME, "loader": "json", "template": "{{ input }}" }) self.assertEqual([1, 2, 3], template.render({"input": [1, 2, 3]}))
def test_bool_cast_false(self): template = UnifiedTemplate({ "type": UNIFIED_TEMPLATE_TYPE_NAME, "loader": "bool", "template": "False" }) self.assertFalse(template.render({}))
def test_type_cast_int(self): template = UnifiedTemplate({ "type": UNIFIED_TEMPLATE_TYPE_NAME, "loader": "int", "template": "{{ input ** 2 }}" }) self.assertEqual(49, template.render({"input": 7}))
def test_bool_cast_true_lowercase(self): template = UnifiedTemplate({ "type": UNIFIED_TEMPLATE_TYPE_NAME, "loader": "bool", "template": "true" }) self.assertTrue(template.render({}))
def __init__(self, items: Dict[str, Any], id: Optional[str] = None): super(AddHistoryEventAction, self).__init__(items, id) self.results = UnifiedTemplate(items.get("results")) self.event_type = UnifiedTemplate(items.get("event_type")) self.event_content = items.get("event_content") if self.event_content: for k, v in self.event_content.items(): self.event_content[k] = UnifiedTemplate(v)
def _get_template_tree(self, value): is_dict_unified_template = isinstance(value, dict) and value.get("type") == UNIFIED_TEMPLATE_TYPE_NAME if isinstance(value, str) or is_dict_unified_template: result = UnifiedTemplate(value) elif isinstance(value, dict): result = {} for inner_key, inner_value in value.items(): result[inner_key] = self._get_template_tree(inner_value) elif isinstance(value, list): result = [] for inner_value in value: result.append(self._get_template_tree(inner_value)) else: result = value return result
def __init__(self, items: Optional[Dict[str, Any]], id: Optional[str] = None) -> None: super(AvailableInfoFiller, self).__init__(items, id) value = items['value'] self.loader = items.get('loader') self.template: UnifiedTemplate = UnifiedTemplate(value)
def __init__(self, items: Dict[str, Any], id: Optional[str] = None): super(SetVariableAction, self).__init__(items, id) self.key: str = items["key"] self.loader = items.get('loader') self.ttl: int = items.get("ttl") value: str = items["value"] self.template: UnifiedTemplate = UnifiedTemplate(value)
def test_support_templates(self): template = UnifiedTemplate({ "type": UNIFIED_TEMPLATE_TYPE_NAME, "support_templates": { "name": "{{ personInfo.name|capitalize }}", "surname": "{{ personInfo.surname|capitalize }}" }, "template": "{{ name }} {{ surname }}", }) self.assertEqual( "Vasya Pupkin", template.render( {"personInfo": { "name": "vasya", "surname": "pupkin" }}))
def _render_request_data(self, action_params): # копируем прежде чем рендерить шаблон хэдеров, чтобы не затереть его request_data = copy(self.request_data) request_data[self.EX_HEADERS_NAME] = { key: UnifiedTemplate(value).render(action_params) for key, value in request_data.get(self.EX_HEADERS_NAME).items() } return request_data
class RegexpInTemplateRequirement(Requirement): def __init__(self, items: Dict[str, Any], id: Optional[str] = None) -> None: super(RegexpInTemplateRequirement, self).__init__(items, id) self._template = UnifiedTemplate(items["template"]) self._regexp = re.compile(items["regexp"], re.S | re.M) def check(self, text_preprocessing_result: BaseTextPreprocessingResult, user: User, params: Dict[str, Any] = None) -> bool: params = params or {} collected = user.parametrizer.collect(text_preprocessing_result) params.update(collected) render_result = self._template.render(params) return True if self._regexp.search(render_result) else False
class TemplateInArrayRequirement(Requirement): def __init__(self, items: Dict[str, Any], id: Optional[str] = None) -> None: super(TemplateInArrayRequirement, self).__init__(items, id) self._template = UnifiedTemplate(items["template"]) self._items = set(items["items"]) def check(self, text_preprocessing_result: BaseTextPreprocessingResult, user: User, params: Dict[str, Any] = None) -> bool: params = params or {} collected = user.parametrizer.collect(text_preprocessing_result) params.update(collected) render_result = self._template.render(params) return render_result in self._items
class AddHistoryEventAction(Action): results: UnifiedTemplate event_type: UnifiedTemplate event_content: Dict[str, UnifiedTemplate] def __init__(self, items: Dict[str, Any], id: Optional[str] = None): super(AddHistoryEventAction, self).__init__(items, id) self.results = UnifiedTemplate(items.get("results")) self.event_type = UnifiedTemplate(items.get("event_type")) self.event_content = items.get("event_content") if self.event_content: for k, v in self.event_content.items(): self.event_content[k] = UnifiedTemplate(v) def run(self, user: User, text_preprocessing_result: BaseTextPreprocessingResult, params: Optional[Dict[str, Union[str, float, int]]] = None) -> None: last_scenario_id = user.last_scenarios.last_scenario_name scenario = user.descriptions["scenarios"].get(last_scenario_id) if scenario: params = user.parametrizer.collect(text_preprocessing_result) if self.event_content: for key, template in self.event_content.items(): self.event_content[key] = template.render(params) self.event_type = self.event_type.render(params) self.results = self.results.render(params) event = Event(type=self.event_type, scenario=scenario.id, scenario_version=scenario.version, results=self.results, content=self.event_content) user.history.add_event(event)
def get_text_by_key(self, bundle_name: str, reply_key="") -> str: result = "" bundle = self._bundles[bundle_name] if bundle: reply_list = None for suffix in self.__suffix: target_key = f"{reply_key}{suffix}" reply_list = bundle.get(target_key) if reply_list: break if reply_list: params = self._user.parametrizer.collect( ) # TODO give run-time action parameters to collect call result_str = random.choice(reply_list) result = UnifiedTemplate(result_str).render(params) else: raise KeyError("Key not found") return result
class TemplateRequirement(Requirement): def __init__(self, items: Dict[str, Any], id: Optional[str] = None) -> None: super(TemplateRequirement, self).__init__(items, id) self._template = UnifiedTemplate(items["template"]) def check(self, text_preprocessing_result: BaseTextPreprocessingResult, user: BaseUser, params: Dict[str, Any] = None) -> bool: params = params or {} collected = user.parametrizer.collect(text_preprocessing_result) params.update(collected) render_result = self._template.render(params) if render_result == "True": return True if render_result == "False": return False raise TypeError( f'Template result should be "True" or "False", got: ', f'{render_result} for template {self.items["template"]}')
def __init__(self, items: Dict[str, Any], id: Optional[str] = None) -> None: super(RegexpInTemplateRequirement, self).__init__(items, id) self._template = UnifiedTemplate(items["template"]) self._regexp = re.compile(items["regexp"], re.S | re.M)
def __init__(self, items: Dict[str, Any], id: Optional[str] = None) -> None: super(ArrayItemInTemplateRequirement, self).__init__(items, id) self._template = UnifiedTemplate(items["template"]) self._items = set(items["items"])
def __init__(self, items: Dict[str, Any], id: Optional[str] = None): super(FillFieldAction, self).__init__(items, id) self.form = items["form"] self.field: str = items["field"] data_path = items["data_path"] self.template: UnifiedTemplate = UnifiedTemplate(data_path)
def __init__(self, items: Dict[str, Any], id: Optional[str] = None): super(RunScenarioAction, self).__init__(items, id) self.scenario: UnifiedTemplate = UnifiedTemplate(items["scenario"])
def test_ordinar_jinja_backward_compatibility(self): template = UnifiedTemplate("abc {{input}}") self.assertEqual("abc def", template.render({"input": "def"}))
def test_args_format_input(self): template = UnifiedTemplate("timestamp: {{ts}}") self.assertEqual("timestamp: 123.45", template.render(ts=123.45))