def _apply(self,
put: unittest.TestCase,
value: SetupSettingsHandler,
message_builder: MessageBuilder,
):
settings_builder_model = asrt_settings_builder.SettingsBuilderAssertionModel(
value.builder,
self.ENVIRONMENT,
self.OS_SERVICES,
)
self._settings_builder.apply(
put,
settings_builder_model,
message_builder.for_sub_component('settings builder'),
)
aei_model = AdvWvAssertionModel(
ApplicationEnvironment(self.OS_SERVICES,
self.ENVIRONMENT.proc_exe_settings,
self.ENVIRONMENT.tmp_dir__path_access.paths_access,
self.ENVIRONMENT.mem_buff_size,
),
value.as_atc_execution_input(),
)
self._atc_exe_input.apply(
put,
aei_model,
message_builder.for_sub_component('act execution info'),
)
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 is_section_item(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder = asrt.MessageBuilder()):
asrt.IsInstance(doc.SectionItem).apply(put, value, message_builder)
assert isinstance(value, doc.SectionItem)
asrt.sub_component('header',
doc.SectionItem.header.fget,
is_text
).apply(put, value, message_builder)
asrt.sub_component('tags',
doc.SectionItem.tags.fget,
asrt.is_instance_with(set,
asrt.on_transformed(list,
asrt.is_sequence_of(asrt.is_instance(str)))
)
).apply(put, value, message_builder)
asrt.sub_component('target',
doc.SectionItem.target.fget,
asrt.is_instance(core.CrossReferenceTarget)),
if isinstance(value, doc.Article):
is_article_contents.apply(put, value.contents,
message_builder.for_sub_component('article_contents'))
elif isinstance(value, doc.Section):
is_section_contents.apply(put, value.contents,
message_builder.for_sub_component('section_contents'))
else:
asrt.fail('Not a {}: {}'.format(str(doc.SectionItem), str(value)))
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 _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_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 _apply(
self,
put: unittest.TestCase,
value: SourceConstructor,
message_builder: MessageBuilder,
):
self._non_contents_related(
put, value,
message_builder.for_sub_component('non-contents-related'))
self._contents_related(
put, value, message_builder.for_sub_component('contents-related'))
def _apply(
self,
put: unittest.TestCase,
value: StringSourceContents,
message_builder: asrt.MessageBuilder,
):
self._check_actual_contents(
put, value, message_builder.for_sub_component('actual contents'))
self._check_external_dependencies(
put, value,
message_builder.for_sub_component(
'may_depend_on_external_resources'))
def _apply(self,
put: unittest.TestCase,
value: Program,
message_builder: MessageBuilder):
asrt.is_instance(Program).apply(put, value, message_builder.for_sub_component('class'))
assert isinstance(value, Program)
self.command.apply(put, value.command, message_builder.for_sub_component('command'))
self.stdin.apply(put, value.stdin, message_builder.for_sub_component('stdin'))
self.transformer.apply(put, value.transformation, message_builder.for_sub_component('transformation'))
def _apply(self, put: unittest.TestCase, value: SubProcessResult,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(
value, SubProcessResult,
message_builder.for_sub_component('class of result object').apply(
'Expects ' + str(SubProcessResult)))
msg_info = _err_msg_info(value)
put.assertEqual(
self.expected.exit_code, value.exitcode,
message_builder.for_sub_component('exitcode').apply(msg_info))
put.assertEqual(
self.expected.exit_identifier + '\n', value.stdout,
message_builder.for_sub_component('exit identifier').apply(
msg_info))
def _apply(self,
put: unittest.TestCase,
value: SubProcessResult,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value,
SubProcessResult,
message_builder.for_sub_component('class of result object').apply(
'Expects ' + str(SubProcessResult)))
msg_info = _err_msg_info(value)
put.assertEqual(self.expected.exit_code,
value.exitcode,
message_builder.for_sub_component('exitcode').apply(msg_info))
put.assertEqual(self.expected.exit_identifier + '\n',
value.stdout,
message_builder.for_sub_component('exit identifier').apply(msg_info))
def _check_resolved_value(self, put: unittest.TestCase,
actual: DependenciesAwareDdv, tcds: TestCaseDs,
message_builder: asrt.MessageBuilder):
assertion_on_resolved_value = self.resolved_value(tcds)
if not actual.has_dir_dependency():
actual_resolved_value = actual.value_when_no_dir_dependencies()
assertion_on_resolved_value.apply(
put, actual_resolved_value,
message_builder.for_sub_component('resolved primitive value'))
actual_resolved_value = actual.value_of_any_dependency(tcds)
assertion_on_resolved_value.apply(
put, actual_resolved_value,
message_builder.for_sub_component('resolved primitive value'))
def _apply(self, put: unittest.TestCase, value: Node,
message_builder: MessageBuilder):
self._assert_object_types(put, value, message_builder)
self._header.apply(put, value.header,
message_builder.for_sub_component('header'))
self._data.apply(put, value.data,
message_builder.for_sub_component('data'))
self._details.apply(put, value.details,
message_builder.for_sub_component('details'))
self._children.apply(put, value.children,
message_builder.for_sub_component('children'))
def _apply(self, put: unittest.TestCase, value,
message_builder: MessageBuilder):
put.assertIsInstance(value, SequenceRenderer,
message_builder.apply('object type'))
assert isinstance(value, SequenceRenderer)
rendered_objects = value.render_sequence()
self._type_sanity_object_assertion.apply(
put, rendered_objects,
message_builder.for_sub_component('rendered objects'))
self._custom_assertion.apply(
put, rendered_objects,
message_builder.for_sub_component('rendered objects'))
def _apply(self, put: unittest.TestCase, value: Program,
message_builder: MessageBuilder):
asrt.is_instance(Program).apply(
put, value, message_builder.for_sub_component('class'))
assert isinstance(value, Program)
self.command.apply(put, value.command,
message_builder.for_sub_component('command'))
self.stdin.apply(put, value.stdin,
message_builder.for_sub_component('stdin'))
self.transformer.apply(
put, value.transformation,
message_builder.for_sub_component('transformation'))
def _contents_related(
self,
put: unittest.TestCase,
constructor: SourceConstructor,
message_builder: MessageBuilder,
):
for contents_access_sequence_case in self._contents_access_sequence_cases:
case_message_builder = message_builder.for_sub_component(
contents_access_sequence_case.name)
ext_dep_case_message_builder = case_message_builder.for_sub_component(
'may-dep-on-ext-rsrc-first')
with constructor.new(
put, ext_dep_case_message_builder) as string_source:
self._contents_related__ext_deps_first(
put,
contents_access_sequence_case.value,
string_source.contents(),
ext_dep_case_message_builder,
)
ext_dep_case_message_builder = case_message_builder.for_sub_component(
'may-dep-on-ext-rsrc-last')
with constructor.new(
put, ext_dep_case_message_builder) as string_source:
self._contents_related__ext_deps_last(
put,
contents_access_sequence_case.value,
string_source.contents(),
ext_dep_case_message_builder,
)
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(
put: unittest.TestCase,
mk_transformer: Callable[[StringSource], StringSource],
source_may_depend_on_external_resources: bool,
num_initial_freeze_invocations: int,
tmp_file_space: DirFileSpace,
source_model_method_invocations: Assertion[Sequence[StringSourceMethod]],
message_builder: asrt.MessageBuilder = asrt.new_message_builder(),
source_model_contents: str = '1\n2\n3\n',
):
source_model_invocations_recorder = _new_recording_media()
source_model = string_sources.of_string(
source_model_contents, tmp_file_space,
source_may_depend_on_external_resources)
source_model_w_invocations_recording = string_sources.StringSourceThatRecordsMethodInvocations(
source_model,
source_model_invocations_recorder,
)
checked_string_source = mk_transformer(
source_model_w_invocations_recording)
# ACT #
_invoke_freeze(checked_string_source, num_initial_freeze_invocations)
_invoke_every_contents_method(checked_string_source)
# ASSERT #
source_model_method_invocations.apply(
put, source_model_invocations_recorder.recordings,
message_builder.for_sub_component(
'invoked methods of the source model'))
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: ApplicationEnvironmentDependentValue[StringTransformer],
message_builder: MessageBuilder,
):
string_transformer = value.primitive(self._environment.app_env)
for source_model_may_depend_on_external_resources in [False, True]:
for num_invocations_of_freeze_before_check in [1, 2]:
case_msg_builder = (message_builder.for_sub_component(
'source_model_may_depend_on_external_resources=' +
str(source_model_may_depend_on_external_resources)
).for_sub_component(
str(num_invocations_of_freeze_before_check) +
' invocations of freeze before check'))
check(
put,
string_transformer.transform,
source_model_may_depend_on_external_resources,
num_invocations_of_freeze_before_check,
self._environment.app_env.tmp_files_space,
source_model_method_invocations=self.
_source_model_method_invocations,
message_builder=case_msg_builder,
)
def _check_value(self, put: unittest.TestCase,
actual: DependenciesAwareDdv, tcds: TestCaseDs,
message_builder: asrt.MessageBuilder):
if not self._expected.has_dir_dependency():
expected = self._expected.value_when_no_dir_dependencies()
assertion = self._value_assertion_from_expected(expected)
assertion.apply(
put, actual.value_when_no_dir_dependencies(),
message_builder.for_sub_component(
'value_when_no_dir_dependencies'))
expected = self._expected.value_of_any_dependency(tcds)
assertion = self._value_assertion_from_expected(expected)
assertion.apply(
put, actual.value_of_any_dependency(tcds),
message_builder.for_sub_component('value_of_any_dependency'))
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 _check_custom_multi(self, put: unittest.TestCase,
actual: MultiDependenciesDdv, tcds: TestCaseDs,
message_builder: asrt.MessageBuilder):
assert isinstance(actual, ListDdv)
elements_assertion = asrt.matches_sequence(
self._sequence_of_element_assertions)
elements_assertion.apply(put, actual.string_elements,
message_builder.for_sub_component('elements'))
def _apply(self,
put: unittest.TestCase,
value: SubProcessResult,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value,
SubProcessResult,
message_builder.for_sub_component('class of result object').apply(
'Expects ' + str(SubProcessResult)))
msg_info = _err_msg_info(value)
self._exitcode.apply(put, value.exitcode,
message_builder.for_sub_component('exitcode' + msg_info))
self._stdout.apply(put, value.stdout,
message_builder.for_sub_component('stdout' + msg_info))
self._stderr.apply(put, value.stderr,
message_builder.for_sub_component('stderr' + msg_info))
def _check_value(self,
put: unittest.TestCase,
actual: DirDependentValue,
home_and_sds: HomeAndSds,
message_builder: asrt.MessageBuilder):
if not self._expected.has_dir_dependency():
expected = self._expected.value_when_no_dir_dependencies()
assertion = self._value_assertion_from_expected(expected)
assertion.apply(put,
actual.value_when_no_dir_dependencies(),
message_builder.for_sub_component('value_when_no_dir_dependencies'))
expected = self._expected.value_of_any_dependency(home_and_sds)
assertion = self._value_assertion_from_expected(expected)
assertion.apply(put,
actual.value_of_any_dependency(home_and_sds),
message_builder.for_sub_component('value_of_any_dependency'))
def _check_resolved_value(self,
put: unittest.TestCase,
actual: DirDependentValue,
tcds: HomeAndSds,
message_builder: asrt.MessageBuilder):
assertion_on_resolved_value = self.resolved_value(tcds)
if not actual.has_dir_dependency():
actual_resolved_value = actual.value_when_no_dir_dependencies()
assertion_on_resolved_value.apply(put,
actual_resolved_value,
message_builder.for_sub_component('resolved primitive value'))
actual_resolved_value = actual.value_of_any_dependency(tcds)
assertion_on_resolved_value.apply(put,
actual_resolved_value,
message_builder.for_sub_component('resolved primitive value'))
def _check_custom_multi(self,
put: unittest.TestCase,
actual: MultiDirDependentValue,
home_and_sds: HomeAndSds,
message_builder: asrt.MessageBuilder):
assert isinstance(actual, StringValue)
fragments_assertion = asrt.matches_sequence(self._sequence_of_fragment_assertions)
fragments_assertion.apply(put, actual.fragments, message_builder.for_sub_component('fragments'))
def _apply(self,
put: unittest.TestCase,
value: str,
message_builder: MessageBuilder,
):
unquoted = shlex.split(value)
num_quoted_elements = asrt.len_equals(1)
num_quoted_elements.apply(
put,
unquoted,
message_builder.for_sub_component('number of quoted elements')
)
self._unquoted.apply(
put,
unquoted[0],
message_builder.for_sub_component('unquoted')
)
def _check_relativity(self,
put: unittest.TestCase,
actual_file_ref: FileRef,
message_builder: asrt.MessageBuilder):
expected = self._expected.relativity()
actual = actual_file_ref.relativity()
assertion = equals_path_relativity(expected)
assertion.apply(put, actual, message_builder.for_sub_component('specific_relativity'))
def _apply(self, put: unittest.TestCase, value: LineMatcher,
message_builder: MessageBuilder):
# ACT #
actual = line_nums_interval.interval_of_matcher(value)
# ASSERT #
self._expected.apply(
put, actual,
message_builder.for_sub_component('interval_of_matcher'))
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: T,
message_builder: MessageBuilder):
with put.assertRaises(HardErrorException) as cx:
self._method_that_should_raise(value)
asrt_text_doc.is_any_text().apply(
put,
cx.exception.error,
message_builder.for_sub_component('error message'),
)
def check(put: unittest.TestCase,
actual: PreOrPostSdsValidator,
arrangement: Arrangement,
expectation: Expectation,
message_builder: asrt.MessageBuilder = asrt.MessageBuilder()):
with home_and_sds_with_act_as_curr_dir(
home_or_sds_contents=arrangement.dir_contents,
symbols=arrangement.symbols) as path_resolving_environment:
actual_validation_result = actual.validate_pre_sds_if_applicable(path_resolving_environment)
expectation.pre_sds.apply(put,
actual_validation_result,
message_builder.for_sub_component('validation pre sds'))
if actual_validation_result is not None:
return
actual_validation_result = actual.validate_post_sds_if_applicable(path_resolving_environment)
expectation.post_sds.apply(put,
actual_validation_result,
message_builder.for_sub_component('validation post sds'))
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: 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 check(put: unittest.TestCase,
actual: DdvValidator,
arrangement: Arrangement,
expectation: Expectation,
message_builder: asrt.MessageBuilder = asrt.MessageBuilder()):
with tcds_with_act_as_curr_dir_2(
tcds_contents=arrangement.dir_contents) as tcds:
actual_validation_result = actual.validate_pre_sds_if_applicable(
tcds.hds)
expectation.pre_sds.apply(
put, actual_validation_result,
message_builder.for_sub_component('validation pre sds'))
if actual_validation_result is not None:
return
actual_validation_result = actual.validate_post_sds_if_applicable(tcds)
expectation.post_sds.apply(
put, actual_validation_result,
message_builder.for_sub_component('validation post sds'))
def _apply(self, put: unittest.TestCase, value: SubProcessResult,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(
value, SubProcessResult,
message_builder.for_sub_component('class of result object').apply(
'Expects ' + str(SubProcessResult)))
msg_info = _err_msg_info(value)
self._exitcode.apply(
put, value.exitcode,
message_builder.for_sub_component('exitcode' + msg_info))
self._stdout.apply(
put, value.stdout,
message_builder.for_sub_component('stdout' + msg_info))
self._stderr.apply(
put, value.stderr,
message_builder.for_sub_component('stderr' + msg_info))
def _check_resolved_value(self, put: unittest.TestCase,
actual: DirDependentValue, tcds: TestCaseDs,
message_builder: asrt.MessageBuilder):
assertion_on_resolved_value = self.resolved_value(tcds)
actual_resolved_value = actual.value_of_any_dependency(tcds)
assertion_on_resolved_value.apply(
put, actual_resolved_value,
message_builder.for_sub_component('resolved primitive value'))
def _apply(
self,
put: unittest.TestCase,
value: FileMatcher,
message_builder: MessageBuilder,
):
actual = value.matches_w_trace(self.MODEL)
asrt_matching_result.matches_value(self.expected).apply(
put, actual,
message_builder.for_sub_component('application result'))
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: 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 _check_resolving_dependencies(self,
put: unittest.TestCase,
actual: DirDependentValue,
message_builder: asrt.MessageBuilder):
self.resolving_dependencies.apply(put,
actual.resolving_dependencies(),
message_builder.for_sub_component('resolving_dependencies'))
actual_resolving_dependencies = actual.resolving_dependencies()
as_dir_dependency_assertion = asrt.equals(bool(actual_resolving_dependencies))
as_dir_dependency_assertion.apply(put,
actual.has_dir_dependency(),
message_builder.for_sub_component('has_dir_dependency'))
should_exist_pre_sds = (not actual_resolving_dependencies
or
actual_resolving_dependencies == {DirectoryStructurePartition.HOME})
asrt.equals(should_exist_pre_sds).apply(put,
actual.exists_pre_sds(),
message_builder.for_sub_component('exists_pre_sds'))
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,
message_builder: asrt.MessageBuilder):
assertion_on_shallow = _equals_target_info_node__shallow(self.expected,
self.mk_equals_cross_ref_id)
assertion_on_shallow.apply(put, value, message_builder)
assert isinstance(value, TargetInfoNode)
for idx, child in enumerate(self.expected.children):
assertion = equals_target_info_node(child, self.mk_equals_cross_ref_id)
assertion.apply(put,
value.children[idx],
message_builder.for_sub_component('children[%d]' % idx))
def _apply(self,
put: unittest.TestCase,
value: SubProcessResult,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value,
SubProcessResult,
message_builder.for_sub_component('class of result object').apply(
'Expects ' + str(SubProcessResult)))
msg_info = _err_msg_info(value)
put.assertEqual(self.expected.exit_code,
value.exitcode,
message_builder.for_sub_component('exitcode').apply(msg_info))
stderr_lines = value.stderr.split('\n')
first_line_of_stderr = '' if not stderr_lines else stderr_lines[0]
put.assertEqual(self.expected.exit_identifier,
first_line_of_stderr,
message_builder.for_sub_component('exit identifier on stderr').apply(msg_info))
put.assertEqual('',
value.stdout,
message_builder.for_sub_component('stdout').apply(msg_info))
def _check_custom(self,
put: unittest.TestCase,
actual: SingleDirDependentValue,
home_and_sds: HomeAndSds,
message_builder: asrt.MessageBuilder):
super()._check_custom(put, actual, home_and_sds, message_builder)
assert isinstance(actual, FileRef)
self._check_path_suffix(put,
actual,
message_builder.for_sub_component('path_suffix'))
self._check_relativity(put, actual, message_builder)
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,
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,
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))
