def test_create_from_plain_values(self): self.assertEqual( { "first": validate.ValuePair("A", "a"), "second": validate.ValuePair("B", "b"), }, validate.values_to_pairs({ "first": "A", "second": "B", }, lambda key, value: value.lower()))
def test_keep_pair_if_is_already_there(self): self.assertEqual( { "first": validate.ValuePair("A", "aaa"), "second": validate.ValuePair("B", "b"), }, validate.values_to_pairs( { "first": validate.ValuePair("A", "aaa"), "second": "B", }, lambda key, value: value.lower()))
def _validate_ticket_options(options, allow_unknown_options): validator_list = ([ validate.NamesIn(constants.TICKET_KEYS, option_type="booth ticket", banned_name_list=constants.GLOBAL_KEYS, **validate.set_warning(report_codes.FORCE_OPTIONS, allow_unknown_options)), ] + [validate.ValueNotEmpty(option, None) for option in options]) normalized_options = validate.values_to_pairs( options, lambda key, value: value.strip()) return validate.ValidatorAll(validator_list).validate(normalized_options)
def test_keep_pair_if_is_already_there(self): self.assertEqual( { "first": validate.ValuePair("A", "aaa"), "second": validate.ValuePair("B", "b"), }, validate.values_to_pairs( { "first": validate.ValuePair("A", "aaa"), "second": "B", }, lambda key, value: value.lower() ) )
def test_create_from_plain_values(self): self.assertEqual( { "first": validate.ValuePair("A", "a"), "second": validate.ValuePair("B", "b"), }, validate.values_to_pairs( { "first": "A", "second": "B", }, lambda key, value: value.lower() ) )
def prepare( report_processor, raw_operation_list, default_operation_list, allowed_operation_name_list, allow_invalid=False ): """ Return operation_list prepared from raw_operation_list and default_operation_list. report_processor is tool for warning/info/error reporting list of dicts raw_operation_list are entered operations that require follow-up care list of dicts default_operation_list are operations defined as default by (most probably) resource agent bool allow_invalid is flag for validation skipping """ operations_to_validate = [ validate.values_to_pairs(op, normalize) for op in raw_operation_list ] report_list = [] options_validators = OPERATION_OPTIONS_VALIDATORS + [ validate.value_in( "name", allowed_operation_name_list, option_name_for_report="operation name", code_to_allow_extra_values=report_codes.FORCE_OPTIONS, allow_extra_values=allow_invalid, ) ] for operation in operations_to_validate: report_list.extend( validate_operation(operation, options_validators) ) operation_list = [ validate.pairs_to_values(op) for op in operations_to_validate ] report_list.extend(validate_different_intervals(operation_list)) #can raise LibraryError report_processor.process_list(report_list) return complete_all_intervals(operation_list) + get_remaining_defaults( report_processor, operation_list, default_operation_list )
def _validate_ticket_options(options, allow_unknown_options): validator_list = [ validate.NamesIn( constants.TICKET_KEYS, option_type="booth ticket", banned_name_list=constants.GLOBAL_KEYS, severity=report.item.get_severity( report_codes.FORCE, allow_unknown_options ), ), ] + [validate.ValueNotEmpty(option, None) for option in options] normalized_options = validate.values_to_pairs( options, lambda key, value: value.strip() ) return validate.ValidatorAll(validator_list).validate(normalized_options)
def _validate_ticket_options(options, allow_unknown_options): severity = reports.item.get_severity(reports.codes.FORCE, allow_unknown_options) validator_list = ([ validate.NamesIn( constants.TICKET_KEYS, option_type="booth ticket", banned_name_list=constants.GLOBAL_KEYS, severity=severity, ), ] + [ validate.ValueNotEmpty(option, None) for option in options if option != "mode" ] + [validate.ValueIn("mode", ["auto", "manual"], severity=severity)]) normalized_options = validate.values_to_pairs( options, lambda key, value: value.strip()) return validate.ValidatorAll(validator_list).validate(normalized_options)
def operations_to_normalized(raw_operation_list): return [ validate.values_to_pairs(op, normalize) for op in raw_operation_list ]
def _operations_to_normalized( raw_operation_list: Iterable[ResourceOperationFilteredIn], ) -> List[validate.TypeOptionNormalizedMap]: return [ validate.values_to_pairs(op, _normalize) for op in raw_operation_list ]
def prepare_options_plain( cib: _Element, report_processor: reports.ReportProcessor, options, ticket: str, resource_id, ): options = options.copy() report_processor.report_list(_validate_options_common(options)) if not ticket: report_processor.report( ReportItem.error( reports.messages.RequiredOptionsAreMissing(["ticket"]))) else: report_processor.report_list(validate_ticket_name(ticket)) options["ticket"] = ticket if not resource_id: report_processor.report( ReportItem.error( reports.messages.RequiredOptionsAreMissing(["rsc"]))) options["rsc"] = resource_id role_value_validator = validate.ValueIn("rsc-role", const.PCMK_ROLES, option_name_for_report="role") role_value_validator.empty_string_valid = True validators = [ role_value_validator, validate.ValueDeprecated( "rsc-role", { const.PCMK_ROLE_PROMOTED_LEGACY: const.PCMK_ROLE_PROMOTED, const.PCMK_ROLE_UNPROMOTED_LEGACY: const.PCMK_ROLE_UNPROMOTED, }, reports.ReportItemSeverity.deprecation(), option_name_for_report="role", ), ] report_processor.report_list( validate.ValidatorAll(validators).validate( validate.values_to_pairs( options, validate.option_value_normalization( {"rsc-role": lambda value: value.capitalize()}), ))) if report_processor.has_errors: raise LibraryError() if "rsc-role" in options: if options["rsc-role"]: options["rsc-role"] = pacemaker.role.get_value_for_cib( options["rsc-role"].capitalize(), tools.are_new_role_names_supported(cib), ) else: del options["rsc-role"] return constraint.prepare_options( tuple(list(ATTRIB) + list(ATTRIB_PLAIN)), options, partial( _create_id, cib, options["ticket"], resource_id, options.get("rsc-role", ""), ), partial(tools.check_new_id_applicable, cib, DESCRIPTION), )