def _check_sub_class_properties(self, put: unittest.TestCase, actual: DependenciesAwareDdv, tcds: TestCaseDs, message_builder: asrt.MessageBuilder): put.assertIsInstance(actual, Max1DependencyDdv, message_builder.apply('class')) assert isinstance(actual, Max1DependencyDdv) # Type info for IDE put.assertEqual(self._resolving_dependency, actual.resolving_dependency(), message_builder.apply('resolving_dependency')) assertion_on_resolved_value = self.resolved_value(tcds) if not self._resolving_dependency or self._resolving_dependency == DirectoryStructurePartition.HDS: resolved_value_pre_sds = actual.value_pre_sds(tcds.hds) assertion_on_resolved_value.apply( put, resolved_value_pre_sds, message_builder.for_sub_component('value_pre_sds')) if not self._resolving_dependency or self._resolving_dependency == DirectoryStructurePartition.NON_HDS: resolved_value_post_sds = actual.value_post_sds(tcds.sds) assertion_on_resolved_value.apply( put, resolved_value_post_sds, message_builder.for_sub_component('value_post_sds'))
def _check_sub_class_properties(self, put: unittest.TestCase, actual: DirDependentValue, tcds: HomeAndSds, message_builder: asrt.MessageBuilder): put.assertIsInstance(actual, SingleDirDependentValue, message_builder.apply('class')) assert isinstance(actual, SingleDirDependentValue) # Type info for IDE put.assertEqual(self._resolving_dependency, actual.resolving_dependency(), message_builder.apply('resolving_dependency')) assertion_on_resolved_value = self.resolved_value(tcds) if not self._resolving_dependency or self._resolving_dependency == DirectoryStructurePartition.HOME: resolved_value_post_sds = actual.value_pre_sds(tcds.hds) assertion_on_resolved_value.apply(put, resolved_value_post_sds, message_builder.for_sub_component('value_pre_sds')) if not self._resolving_dependency or self._resolving_dependency == DirectoryStructurePartition.NON_HOME: resolved_value_post_sds = actual.value_post_sds(tcds.sds) assertion_on_resolved_value.apply(put, resolved_value_post_sds, message_builder.for_sub_component('value_pre_sds'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, rs.SymbolTable) assert isinstance(value, rs.SymbolTable) put.assertEqual(self.expected.names_set, value.names_set, message_builder.apply('names in symbol table')) for name in self.expected.names_set: actual_value = value.lookup(name) put.assertIsInstance(actual_value, rs.SymbolContainer, message_builder.apply('actual container for ' + name)) assert isinstance(actual_value, rs.SymbolContainer) expected_container = self.expected.lookup(name) put.assertIsInstance(expected_container, rs.SymbolContainer, message_builder.apply('expected container for ' + name)) assert isinstance(expected_container, rs.SymbolContainer) equals_container(expected_container).apply(put, actual_value, message_builder.for_sub_component('Value of symbol ' + name))
def _check_common_dependencies(self, put: unittest.TestCase, actual: DependenciesAwareDdv, message_builder: asrt.MessageBuilder): put.assertEqual(self._expected.has_dir_dependency(), actual.has_dir_dependency(), message_builder.apply('has_dir_dependency')) put.assertEqual(self._expected.resolving_dependencies(), actual.resolving_dependencies(), message_builder.apply('resolving_dependencies'))
def _apply(self, put: unittest.TestCase, value: T, message_builder: MessageBuilder): file_path = pathlib.Path(self.path_name) put.assertTrue(file_path.exists(), message_builder.apply('Path should exist')) put.assertTrue(file_path.is_dir(), message_builder.apply('Path should be a directory'))
def _check_common_dependencies(self, put: unittest.TestCase, actual: DirDependentValue, message_builder: asrt.MessageBuilder): put.assertEqual(self._expected.has_dir_dependency(), actual.has_dir_dependency(), message_builder.apply('has_dir_dependency')) put.assertEqual(self._expected.resolving_dependencies(), actual.resolving_dependencies(), message_builder.apply('resolving_dependencies'))
def _apply( self, put: unittest.TestCase, value: Either[SymbolName, StringSdv], message_builder: MessageBuilder, ): put.assertTrue(value.is_left(), message_builder.apply('form of Either')) put.assertEqual( self._expected_symbol_name, value.left(), message_builder.apply('value of Either (left SymbolName)'))
def _apply(self, put: unittest.TestCase, value, message_builder: MessageBuilder, ): put.assertIsInstance(value, SetupSettingsBuilder, message_builder.apply('object should be instance of ' + str(type(SetupSettingsBuilder))) ) assert isinstance(value, SetupSettingsBuilder) # Type info for IDE put.assertIsNone(value.stdin, message_builder.apply('stdin')) self._environ.apply(put, value.environ, message_builder.for_sub_component('environ'))
def _apply(self, put: unittest.TestCase, value: DdvValidator, message_builder: MessageBuilder): validation_result = value.validate_pre_sds_if_applicable(self.tcds.hds) self.expectation.pre_sds.apply_with_message( put, validation_result, message_builder.apply('pre sds validation')) if validation_result is None: validation_result = value.validate_post_sds_if_applicable( self.tcds) self.expectation.post_sds.apply_with_message( put, validation_result, message_builder.apply('post sds validation'))
def _apply( self, put: unittest.TestCase, value: ValueRestriction, message_builder: MessageBuilder, ): put.assertIsInstance(value, ArbitraryValueWStrRenderingRestriction, message_builder.apply('object type')) assert isinstance( value, ArbitraryValueWStrRenderingRestriction) # Type info for IDE put.assertEqual(self._accepted, value.accepted, message_builder.apply('accepted types'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, ConstantStringFragmentResolver) assert isinstance(value, ConstantStringFragmentResolver) # Type info for IDE put.assertTrue(value.is_string_constant, message_builder.apply('is_string_constant')) put.assertEqual(self.expected.string_constant, value.string_constant, message_builder.apply('string_constant'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): model = value assert isinstance(model, SettingsBuilderAssertionModel) # Type info for IDE put.assertIsNone(model.actual.stdin.file_name, message_builder.apply('file name should not be set when using here doc')) expected_contents_str = self.expected_contents_resolver.resolve_value_of_any_dependency( model.environment.path_resolving_environment_pre_or_post_sds) put.assertEqual(expected_contents_str, model.actual.stdin.contents, message_builder.apply('stdin as contents'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): model = value assert isinstance(model, SettingsBuilderAssertionModel) # Type info for IDE put.assertIsNone(model.actual.stdin.contents, message_builder.apply('contents should not be set when using file')) expected_file_name = self._expected_file_reference.value_of_any_dependency( model.environment.path_resolving_environment_pre_or_post_sds.home_and_sds) put.assertEqual(expected_file_name, model.actual.stdin.file_name, message_builder.apply('Name of stdin file in Setup Settings'))
def _check_custom(self, put: unittest.TestCase, actual: Max1DependencyDdv, tcds: TestCaseDs, message_builder: asrt.MessageBuilder): if self._expected.exists_pre_sds(): put.assertEqual( self._expected_single_dep_value.value_pre_sds(tcds.hds), actual.value_pre_sds(tcds.hds), message_builder.apply('value_pre_sds')) else: put.assertEqual( self._expected_single_dep_value.value_post_sds(tcds.sds), actual.value_post_sds(tcds.sds), message_builder.apply('value_post_sds')) self._check_custom_single(put, actual, tcds, message_builder)
def _apply(self, put: unittest.TestCase, value: PreOrPostSdsValueValidator, message_builder: MessageBuilder): validation_result = value.validate_pre_sds_if_applicable(self.tcds.hds) self.expectation.pre_sds.apply_with_message(put, validation_result, message_builder.apply('pre sds validation')) if validation_result is None: validation_result = value.validate_post_sds_if_applicable(self.tcds) self.expectation.post_sds.apply_with_message(put, validation_result, message_builder.apply('post sds validation'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, SymbolStringFragmentSdv) assert isinstance(value, SymbolStringFragmentSdv) # Type info for IDE put.assertFalse(value.is_string_constant, message_builder.apply('is_string_constant')) put.assertEqual(self.expected.symbol_name, value.symbol_name, message_builder.apply('symbol_name'))
def _check_custom(self, put: unittest.TestCase, actual: SingleDirDependentValue, home_and_sds: HomeAndSds, message_builder: asrt.MessageBuilder): if self._expected.exists_pre_sds(): put.assertEqual(self._expected_single_dep_value.value_pre_sds(home_and_sds.hds), actual.value_pre_sds(home_and_sds.hds), message_builder.apply('value_pre_sds')) else: put.assertEqual(self._expected_single_dep_value.value_post_sds(home_and_sds.sds), actual.value_post_sds(home_and_sds.sds), message_builder.apply('value_post_sds')) self._check_custom_single(put, actual, home_and_sds, message_builder)
def _apply( self, put: unittest.TestCase, value: List[str], message_builder: MessageBuilder, ): key_msg = message_builder.apply('key') val_msg = message_builder.apply('value') actual_as_dict = self._dict_from_lines(value) for ek, ev in self.expected_sub_set.items(): put.assertIn(ek, actual_as_dict, key_msg) put.assertEqual(ev, actual_as_dict[ek], val_msg)
def _apply(self, put: unittest.TestCase, value: PreOrPostSdsValidator, message_builder: MessageBuilder): environment = PathResolvingEnvironmentPreOrPostSds(self.tcds, self.symbols) validation_result = value.validate_pre_sds_if_applicable(environment) self.expectation.pre_sds.apply_with_message(put, validation_result, message_builder.apply('pre sds validation')) if validation_result is None: validation_result = value.validate_post_sds_if_applicable(environment) self.expectation.post_sds.apply_with_message(put, validation_result, message_builder.apply('post sds validation'))
def _apply(self, put: unittest.TestCase, value: SymbolDependentValue, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, SymbolDependentValue, message_builder.apply("SDV type")) self.sdv_type.apply(put, value, message_builder) references__actual = value.references references__message_builder = message_builder.for_sub_component('references') asrt.is_sequence_of(asrt.is_instance(SymbolReference)).apply( put, references__actual, references__message_builder ) self.references.apply(put, references__actual, references__message_builder) self.custom.apply(put, value, message_builder) ddv = value.resolve(self.symbols) self.ddv.apply(put, ddv, message_builder.for_sub_component('ddv'))
def _apply(self, put: unittest.TestCase, value: spe.ResultAndStderr, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, spe.ResultAndStderr) put.assertTrue(value.result.is_success, message_builder.apply('Result is expected to indicate success'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, type(self.expected), message_builder.apply('type of CrossReferenceId')) equality_checker = _CrossReferenceTargetEqualsWhenClassIsEqual(self.expected, put, message_builder) equality_checker.visit(value)
def _check_custom_dependencies(self, put: unittest.TestCase, actual: MultiDependenciesDdv, tcds: TestCaseDs, message_builder: asrt.MessageBuilder): put.assertEqual(self._expected_multi_dep_value.dir_dependencies(), actual.dir_dependencies(), message_builder.apply('dir_dependency'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, type(self.expected), message_builder.apply('type of CrossReferenceId')) equality_checker = _CrossReferenceIdEqualsWhenClassIsEqual(self.expected, put, message_builder) equality_checker.visit(value)
def _check_primitive( self, primitive: PRIMITIVE, resolving_env: FullResolvingEnvironment, message_builder: MessageBuilder, ) -> _ValueAssertionApplier: self.common_properties.check_primitive( self.put, primitive, message_builder, ) assertion_on_primitive = self.primitive( AssertionResolvingEnvironment( resolving_env.tcds, resolving_env.application_environment)) assertion_on_primitive.apply(self.put, primitive, message_builder) try: result = self.applier.apply(self.put, message_builder, primitive, resolving_env, self.model_constructor) if self.execution.is_hard_error is not None: self.put.fail( message_builder.apply('HARD_ERROR not reported (raised)')) self.common_properties.check_application_output( self.put, result, message_builder.for_sub_component( 'common properties of output')) return _ValueAssertionApplier( self.execution.main_result, result, message_builder.for_sub_component('output'), ) except HardErrorException as ex: return self._check_hard_error(ex, message_builder)
def _check_existence(self, put: unittest.TestCase, actual: DirDependentValue, message_builder: asrt.MessageBuilder): put.assertEqual(self._expected.exists_pre_sds(), actual.exists_pre_sds(), message_builder.apply('exists_pre_sds'))
def _apply(self, put: unittest.TestCase, value: MatcherWTrace[MODEL], message_builder: asrt.MessageBuilder): put.assertIsInstance(value, MatcherWTrace) assert isinstance(value, MatcherWTrace) # Type info for IDE # Check description actual_structure = value.structure().render() expected_structure = self.expected_equivalent.structure().render() put.assertEqual(expected_structure.header, actual_structure.header, message_builder.apply('header')) # Check applications application_assertions = asrt.and_([ MatcherEquivalenceOfCaseAssertion(self.expected_equivalent, model_info) for model_info in self._model_infos ]) application_assertions.apply(put, value, message_builder.for_sub_component('application'))
def dir_file_space_for_single_usage_getter( put: unittest.TestCase, message_builder: MessageBuilder) -> ContextManager[DirFileSpace]: with tmp_dir.tmp_dir() as storage_dir: yield TmpFileSpaceThatAllowsSinglePathGeneration( put, storage_dir, 'path-name', message_builder.apply('dir-file-space'))
def _check_type(self, put: unittest.TestCase, actual, message_builder: asrt.MessageBuilder ): put.assertIsInstance(actual, self._expected_type, message_builder.apply('Actual value is expected to be a ' + str(self._expected_type)))
def _check_custom_dependencies(self, put: unittest.TestCase, actual: MultiDirDependentValue, home_and_sds: HomeAndSds, message_builder: asrt.MessageBuilder): put.assertEqual(self._expected_multi_dep_value.dir_dependencies(), actual.dir_dependencies(), message_builder.apply('dir_dependency'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, spe.ResultAndStderr) put.assertEqual(self.exit_code, value.result.exit_code, message_builder.apply('Exit code'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, spe.ResultAndStderr) put.assertEqual(self.stderr_contents, value.stderr_contents, message_builder.apply('Stderr contents'))
def _apply(self, put: unittest.TestCase, value: LineObject, message_builder: MessageBuilder): put.assertIsInstance(value, LineObject, message_builder.apply('object type')) assert isinstance(value, LineObject) self._is_known_sub_class(put, value, message_builder) value.accept(self._LINE_OBJECT_CHECKER, put)
def _apply(self, put: unittest.TestCase, value: HomeAndSds, message_builder: asrt.MessageBuilder): relativity_root = REL_OPTIONS_MAP[self.relativity].root_resolver.from_home_and_sds(value) put.assertEqual(relativity_root / self.expected_sub_dir_of_act_dir, pathlib.Path.cwd(), message_builder.apply('CWD expected to be sub-dir of ' + str(self.relativity)))
def _check_custom_dependencies(self, put: unittest.TestCase, actual: SingleDirDependentValue, home_and_sds: HomeAndSds, message_builder: asrt.MessageBuilder): put.assertEqual(self._expected_single_dep_value.resolving_dependency(), actual.resolving_dependency(), message_builder.apply('resolving_dependency'))
def _apply( self, put: unittest.TestCase, value: IntegerDdv, message_builder: MessageBuilder, ): actual = value.value_of_any_dependency(self._environment.tcds) put.assertEqual(self._expected_resolved_value, actual, message_builder.apply('int value'))
def _apply(self, put: unittest.TestCase, value: AdvWvAssertionModel[T], message_builder: MessageBuilder): result_of_validation = value.adv.validate() put.assertIsNone(result_of_validation, message_builder.apply('validation result')) resolved_value = value.adv.resolve(value.environment) self._resolved_value.apply( put, resolved_value, message_builder.for_sub_component('resolved value'))
def _apply(self, put: unittest.TestCase, value: FailureDetails, message_builder: MessageBuilder): put.assertIsNotNone(value, message_builder.apply('must not be none')) put.assertIsInstance(value, FailureDetails, message_builder.apply('type of object')) if self._error_message_or_none is not None: message_comp_builder = message_builder.for_sub_component( 'failure message') put.assertIsNotNone(value.failure_message, message_comp_builder) self._error_message_or_none.apply( put, value.failure_message, message_comp_builder.for_sub_component('text-doc')) self._exception_or_none.apply( put, value.exception, message_builder.for_sub_component('exception'))
def _apply(self, put: unittest.TestCase, value: TestCaseDs, message_builder: asrt.MessageBuilder): relativity_root = REL_OPTIONS_MAP[ self.relativity].root_resolver.from_tcds(value) put.assertEqual( relativity_root / self.expected_sub_dir_of_act_dir, pathlib.Path.cwd(), message_builder.apply('CWD expected to be sub-dir of ' + str(self.relativity)))
def _apply(self, put: unittest.TestCase, value: Detail, message_builder: MessageBuilder): put.assertIsInstance(value, Detail, message_builder.apply('object type')) assert isinstance(value, Detail) self._is_known_sub_class(put, value, message_builder) detail_checker = _IsValidDetail(put, message_builder) value.accept(detail_checker)
def _apply(self, put: unittest.TestCase, value: SandboxDs, message_builder: MessageBuilder): put.assertIsInstance(value, SandboxDs) fc = FileChecker(put, message_builder.apply('')) is_sandbox_directory_structure_after_execution(fc, str(value.root_dir))
def _assert_object_types(self, put: unittest.TestCase, value: Node, message_builder: MessageBuilder): put.assertIsInstance(value, Node, message_builder.apply('Node object type')) self._HEADER_IS_STR.apply(put, value, message_builder) self._IS_SEQUENCE_OF_DETAIL.apply(put, value.details, message_builder) asrt.every_element('children', matches_node()).apply(put, value.children, message_builder)
def _apply(self, put: unittest.TestCase, value: SandboxDs, message_builder: MessageBuilder): sds_root = REL_SDS_RESOLVERS[self.expected_location].from_sds(value) expected = sds_root / self.expected_base_name actual = pathlib.Path().cwd() put.assertEqual(expected, actual, message_builder.apply('current directory'))
def _apply(self, put: unittest.TestCase, value: SandboxDirectoryStructure, message_builder: MessageBuilder): put.assertIsInstance(value, SandboxDirectoryStructure) fc = FileChecker(put, message_builder.apply('')) is_sandbox_directory_structure_after_execution(fc, str(value.root_dir))
def _apply(self, put: unittest.TestCase, value: str, message_builder: asrt.MessageBuilder): reg_ex = re.compile(self._reg_ex) match = reg_ex.fullmatch(value) if match is None: put.fail( message_builder.apply('Do not match pattern [{}]: [{}]'.format( repr(self._reg_ex), value, )))
def _apply(self, put: unittest.TestCase, value: DetailsRenderer, message_builder: MessageBuilder): put.assertIsInstance(value, DetailsRenderer, message_builder.apply('object type')) rendered_details = value.render() self._rendered_details.apply( put, rendered_details, message_builder.for_sub_component('rendered details'))
def _apply( self, put: unittest.TestCase, value: T, message_builder: MessageBuilder, ): for matcher, expected in self._matchers_and_expected_s: asrt.equals(expected).apply_with_message( put, matcher.media.recordings, message_builder.apply(matcher.name_for_err_msgs))
def _check_validation_post_sds(self, matcher_ddv: FullDepsDdv[PRIMITIVE], message_builder: MessageBuilder): validator = matcher_ddv.validator result = validator.validate_post_sds_if_applicable(self.tcds) self.execution.validation.post_sds.apply_with_message( self.put, result, message_builder.apply('validation post sds')) if result is not None: raise StopAssertion()
def _apply(self, put: unittest.TestCase, value: NodeRenderer, message_builder: MessageBuilder): put.assertIsInstance(value, NodeRenderer, message_builder.apply('object type')) rendered_node = value.render() self._rendered_node.apply( put, rendered_node, message_builder.for_sub_component('rendered node'))
def _apply(self, put: unittest.TestCase, value: str, message_builder: MessageBuilder): put.assertIsInstance(value, str) fc = FileChecker(put, message_builder.apply('')) sds = SandboxDirectoryStructure(value) fc.assert_exists_dir_with_given_number_of_files_in_it(sds.root_dir, len(sds.all_root_dirs__including_result())) for d in sds.all_leaf_dirs__including_result(): fc.assert_exists_dir(d)
def _check_sub_class_properties(self, put: unittest.TestCase, actual: DirDependentValue, tcds: HomeAndSds, message_builder: asrt.MessageBuilder): put.assertIsInstance(actual, MultiDirDependentValue, message_builder.apply('class')) assert isinstance(actual, MultiDirDependentValue) # Type info for IDE actual_dir_dependencies = actual.dir_dependencies() asrt.equals(self._dir_dependencies).apply(put, actual_dir_dependencies, message_builder.for_sub_component('dir_dependencies'))
def _apply(self, put: unittest.TestCase, actual, message_builder: asrt.MessageBuilder): assert_is_string_transformer_type = asrt.is_instance(StringTransformer, self.description) assert_is_string_transformer_type.apply_with_message( put, actual, message_builder.apply('Value must be a ' + str(StringTransformer))) assert isinstance(actual, StringTransformer) # Type info for IDE checker = _EqualityChecker(put, message_builder, actual, self.description ) checker.visit(self.expected)
def _apply(self, put: unittest.TestCase, value: SubProcessResultInfo, message_builder: asrt.MessageBuilder): actual_sds_directory = get_printed_sds_or_fail(put, value.sub_process_result) sds = sandbox_directory_structure.SandboxDirectoryStructure(actual_sds_directory) actually_printed_variables = _get_act_output_to_stdout(sds).splitlines() expected_printed_variables = [ '%s=%s' % (environment_variables.ENV_VAR_HOME_CASE, str(value.file_argument.parent)), '%s=%s' % (environment_variables.ENV_VAR_ACT, str(sds.act_dir)), '%s=%s' % (environment_variables.ENV_VAR_TMP, str(sds.user_tmp_dir)), ] put.assertEqual(expected_printed_variables, actually_printed_variables, message_builder.apply('Environment variables printed by the act script')) remove_if_is_directory(actual_sds_directory)
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): is_target_info.apply(put, value, message_builder) assert isinstance(value, TargetInfo) put.assertEqual(self.expected.presentation_text.value, value.presentation_text.value, message_builder.apply('presentation_str')) put.assertIsInstance(value.target, CrossReferenceTarget, 'Actual value is not a ' + str(CrossReferenceTarget)) expected_target = self.expected.target assert isinstance(expected_target, CrossReferenceTarget) assertion = self.mk_equals_cross_ref_id(expected_target) assertion.apply(put, value.target, message_builder.for_sub_component('target'))
def _apply(self, put: unittest.TestCase, value: rs.SymbolValueResolver, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, rs.SymbolValueResolver, message_builder.apply("resolver type")) self.resolver_type.apply(put, value, message_builder) self.references.apply(put, value.references, message_builder.for_sub_component('references')) self.custom.apply(put, value, message_builder) resolved_value = value.resolve(self.symbols) self.resolved_value.apply(put, resolved_value, message_builder.for_sub_component('resolved value'))
def _apply(self, put: unittest.TestCase, value, message_builder: asrt.MessageBuilder): put.assertIsInstance(value, Sequence, 'Expects a Sequence of symbol references') put.assertEqual(len(self._expected), len(value), message_builder.apply('Number of symbol references')) for idx, expected_ref in enumerate(self._expected): actual_ref = value[idx] put.assertIsInstance(actual_ref, su.SymbolReference) assert isinstance(actual_ref, su.SymbolReference) assert isinstance(expected_ref, su.SymbolReference) element_assertion = equals_symbol_reference(expected_ref) element_assertion.apply(put, actual_ref, message_builder.for_sub_component('[%d]' % idx))
def _apply(self, put: unittest.TestCase, value, message_builder: MessageBuilder): put.assertIsInstance(value, ResultWithTransformationData, message_builder.apply("result object class")) assert isinstance(value, ResultWithTransformationData) # Type info for IDE pr = value.process_result self.exitcode.apply(put, pr.exitcode, message_builder.for_sub_component('exitcode')) self.stdout_contents.apply(put, pr.stdout, message_builder.for_sub_component('stdout')) self.stderr_contents.apply(put, pr.stderr, message_builder.for_sub_component('stderr')) self.contents_after_transformation.apply(put, value.result_of_transformation, message_builder.for_sub_component('contents_after_transformation'))
def _apply(self, put: unittest.TestCase, value: FailureDetails, message_builder: MessageBuilder): self.assertions(put, value, message_builder.apply(''))