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: 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 _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(''))
