def __init__(self, files: Sequence[FileSpecificationDdv]): self._files = files validators = [ file.validator() for file in files ] self._validator = ddv_validators.all_of(validators)
def __init__( self, operands: Sequence[MatcherDdv[MODEL]], model_freezer: Callable[[MODEL], MODEL], ): self._operands = operands self._model_freezer = model_freezer self._validator = ddv_validators.all_of( [matcher.validator for matcher in operands])
def __init__(self, name: str, range_expr_handlers: Sequence[_RangeExprHandler], ): self._name = name self._range_expr_handlers = range_expr_handlers self._validator = ddv_validators.all_of([ reh.validator for reh in range_expr_handlers ])
def validator(self) -> DdvValidator: return ( self._regex.validator() if self._lines_selector is None else ddv_validators.all_of([ self._lines_selector.validator, self._regex.validator(), ]) )
def _assert_passes_validation( self, actual: PathSdv, environment: PathResolvingEnvironmentPreOrPostSds): path_as_exe_file_cmd = command_sdvs.for_executable_file(actual) actual_validator = ddv_validators.all_of( path_as_exe_file_cmd.resolve(environment.symbols).validators) assertion = ddv_assertions.DdvValidationAssertion.of_expectation( validation.Expectation.passes_all(), environment.tcds) assertion.apply_with_message(self, actual_validator, 'validation')
def __init__(self, name: str, maker: FileMakerDdv, ): self.name = name self.maker = maker self._validator = ddv_validators.all_of([ _IsValidPosixPath(name), self.maker.validator, ])
def __init__( self, min_depth: Optional[IntegerDdv], max_depth: Optional[IntegerDdv], ): self._min_depth = min_depth self._max_depth = max_depth self._validator = ddv_validators.all_of([ int_ddv.validator() for int_ddv in [min_depth, max_depth] if int_ddv is not None ])
def validator_validator_of_files(self) -> DdvValidator: validators = [] for file_name, mb_matcher in self._files: validators.append( _IsRelativePosixPath( file_name.value_when_no_dir_dependencies())) if mb_matcher is not None: validators.append(mb_matcher.validator) return ddv_validators.all_of(validators)
def __init__( self, names: NamesSetup, model_constructor: FullDepsWithDetailsDescriptionDdv[ ModelConstructor[CONTENTS_MATCHER_MODEL]], contents_matcher: MatcherDdv[CONTENTS_MATCHER_MODEL], ): self._names = names self._model_constructor = model_constructor self._contents_matcher = contents_matcher self._validators = ddv_validators.all_of( (model_constructor.validator, contents_matcher.validator))
def __init__(self, matcher: MatcherDdv[PROP_TYPE], property_getter: PropertyGetterDdv[MODEL, PROP_TYPE], describer: PropertyMatcherDescriber, get_int_interval_of_prop_matcher: Optional[Callable[[MatcherWTrace[PROP_TYPE]], IntIntervalWInversion]] = None, ): self._matcher = matcher self._property_getter = property_getter self._describer = describer self._get_int_interval_of_prop_matcher = get_int_interval_of_prop_matcher self._validator = ddv_validators.all_of([ self._matcher.validator, self._property_getter.validator, ])
def _assert_does_not_pass_validation( self, actual: PathSdv, environment: PathResolvingEnvironmentPreOrPostSds): path_as_exe_file_cmd = command_sdvs.for_executable_file(actual) actual_validator = ddv_validators.all_of( path_as_exe_file_cmd.resolve(environment.symbols).validators) passes_pre_sds = not self.configuration.exists_pre_sds passes_post_sds = not passes_pre_sds expectation = validation.Expectation( passes_pre_sds=passes_pre_sds, passes_post_sds=passes_post_sds, ) assertion = ddv_assertions.DdvValidationAssertion.of_expectation( expectation, environment.tcds) assertion.apply_with_message(self, actual_validator, 'validation')
def _check(self, arguments_str: str, expected_source_after_parse: Assertion[ParseSource], expectation_on_exe_file: ExpectationOnExeFile, validator_expectation: validation.Expectation): # ARRANGE # source = ParseSource(arguments_str) # ACT # exe_file = sut.parser().parse(source) # ASSERT # utils.check_exe_file(self, expectation_on_exe_file, exe_file) expected_source_after_parse.apply_with_message(self, source, 'parse source') exe_file_command = command_sdvs.for_executable_file(exe_file) with tcds_with_act_as_curr_dir() as environment: actual_validator = ddv_validators.all_of( exe_file_command.resolve(environment.symbols).validators) assertion = ddv_assertions.DdvValidationAssertion.of_expectation( validator_expectation, environment.tcds) assertion.apply_with_message(self, actual_validator, 'validation')
def check(put: unittest.TestCase, instruction_argument_string: str, arrangement: Arrangement, expectation: Expectation): # ARRANGE # source = ParseSource(instruction_argument_string) # ACT # actual_exe_file = parse_executable_file_path.parser().parse(source) # ASSERT # exe_file_as_command = command_sdvs.for_executable_file(actual_exe_file) expectation.source.apply_with_message(put, source, 'parse source') check_exe_file(put, expectation.expectation_on_exe_file, actual_exe_file) with tcds_with_act_as_curr_dir( tcds_contents=arrangement.tcds_populator) as environment: os.mkdir('act-cwd') os.chdir('act-cwd') actual_validator = ddv_validators.all_of( exe_file_as_command.resolve(environment.symbols).validators) assertion = ddv_assertions.DdvValidationAssertion.of_expectation( expectation.validation_result, environment.tcds) assertion.apply_with_message(put, actual_validator, 'validation')
def validator(self) -> DdvValidator: return ddv_validators.all_of(self._validators)
def _ddvs(self, symbols: SymbolTable) -> Tuple[ModelGetterDdv[MODEL], MatcherDdv[MODEL], DdvValidator]: model_getter = self._model_getter.resolve(symbols) matcher = self._matcher.resolve(symbols) return (model_getter, matcher, ddv_validators.all_of([model_getter.validator, matcher.validator]))
def get_validator(symbols: SymbolTable) -> DdvValidator: return ddv_validators.all_of( executable_object.program.resolve(symbols).validators)
def validator(self) -> DdvValidator: return ddv_validators.all_of( [self._transformed.validator, self._transformer.validator])
def get_ddv_validator(symbols: SymbolTable) -> DdvValidator: return ddv_validators.all_of([ model_constructor.resolve(symbols).validator, files_matcher.resolve(symbols).validator, ])
def get_interpreter_and_args_validator( symbols: SymbolTable) -> DdvValidator: return ddv_validators.all_of( tuple(self._interpreter.resolve(symbols).validators) + tuple(info.arguments.resolve(symbols).validators))