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 _apply(self, put: unittest.TestCase,
actual_phase_2_step_2_recorded_value,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(actual_phase_2_step_2_recorded_value, dict,
'actual value should be a dictionary')
for phase in sorted(self.expected_phase_2_step_2_recorded_value.keys(),
key=attrgetter('value')):
put.assertIn(phase, self.expected_phase_2_step_2_recorded_value)
expected_steps = self.expected_phase_2_step_2_recorded_value[phase]
actual = actual_phase_2_step_2_recorded_value[phase]
for expected_step in sorted(expected_steps.keys()):
put.assertIn(
expected_step, actual,
'Phase {}: Missing step: {}'.format(phase, expected_step))
put.assertEqual(expected_steps[expected_step],
actual[expected_step],
'{}/{}'.format(phase, expected_step))
put.assertEqual(
len(expected_steps), len(actual),
'Actual number of recorded steps for phase {} must not exceed expected'
.format(phase))
put.assertEqual(
len(self.expected_phase_2_step_2_recorded_value),
len(actual_phase_2_step_2_recorded_value),
'Actual number of recorded phases must not exceed expected'
)
# To be sure that above code does not miss any case
put.assertEqual(self.expected_phase_2_step_2_recorded_value,
actual_phase_2_step_2_recorded_value,
'Recordings per phase and step')
def _apply(self,
put: unittest.TestCase,
value: Any,
message_builder: MessageBuilder):
put.assertIsInstance(value,
self.expected,
message_builder.apply(self.message))
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_table(test: unittest.TestCase, table: pd.DataFrame, colnames):
test.assertIsInstance(table, pd.DataFrame)
test.assertGreater(len(table), 0)
test.assertTrue(table.shape[1], 2)
test.assertTrue(table.notnull().values.any())
test.assertTrue((table.iloc[:, 0] != 0).any())
test.assertEqual(tuple(table.columns), colnames)
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 check_both_single_and_multiple_line_source(
self,
put: unittest.TestCase,
first_source_line_instruction_argument_source_template: str,
act_phase_source_lines: list,
expected_cmd_and_args: ValueAssertion,
hds_contents: home_populators.HomePopulator = home_populators.empty()):
instruction_argument_source = first_source_line_instruction_argument_source_template.format_map(
self.format_map_for_template_string)
for source, source_assertion in equivalent_source_variants_with_assertion(put, instruction_argument_source):
# ARRANGE #
os_process_executor = AtcOsProcessExecutorThatRecordsArguments()
arrangement = Arrangement(source,
act_phase_source_lines,
atc_os_process_executor=os_process_executor,
hds_contents=hds_contents)
expectation = Expectation(source_after_parse=source_assertion)
# ACT #
check(put, arrangement, expectation)
# ASSERT #
put.assertFalse(os_process_executor.command.shell,
'Command should not indicate shell execution')
actual_cmd_and_args = os_process_executor.command.args
put.assertIsInstance(actual_cmd_and_args, list,
'Arguments of command to execute should be a list of arguments')
put.assertTrue(len(actual_cmd_and_args) > 0,
'List of arguments is expected to contain at least the file|interpreter argument')
expected_cmd_and_args.apply_with_message(put, actual_cmd_and_args, 'actual_cmd_and_args')
def run_rdb_assertions(
cls,
test_case: unittest.TestCase,
retriever: Retriever,
definition: specification.ThresholdSpecification
):
test_case.assertIsInstance(retriever, threshold.disk.RDBThresholdRetriever)
data: pandas.DataFrame = retriever.retrieve()
test_case.assertEqual(sorted([column for column in data.keys()]), ['name', 'site_no', 'value'])
test_case.assertEqual(len(data.site_no.unique()), 2)
test_case.assertEqual(len(data.index.unique()), 366)
test_case.assertEqual(data.index.name, 'threshold_day')
created_thresholds = threshold.get_thresholds(definition)
test_case.assertEqual(len(data.site_no.unique()), len(created_thresholds))
for key, thresholds in created_thresholds.items():
test_case.assertIn(key, data.site_no.unique())
for threshold_name, group_data in data[data.site_no == key].groupby(['name']):
matching_thresholds = [
thresh
for thresh in thresholds
if thresh.name == threshold_name
]
test_case.assertEqual(len(matching_thresholds), 1)
matching_threshold = matching_thresholds[0]
test_case.assertIn(threshold_name, definition)
threshold_definition = definition[threshold_name]
test_case.assertEqual(threshold_definition.weight, matching_threshold.weight)
def _apply(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value, tuple,
'Expects a tuple of StringFragments')
asrt.matches_sequence(self._sequence_of_element_assertions).apply(put, value, 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: 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,
actual_phase_2_step_2_recorded_value,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(actual_phase_2_step_2_recorded_value, dict,
'actual value should be a dictionary')
for phase in sorted(self.expected_phase_2_step_2_recorded_value.keys(),
key=attrgetter('value')):
put.assertIn(phase, self.expected_phase_2_step_2_recorded_value)
expected_steps = self.expected_phase_2_step_2_recorded_value[phase]
actual = actual_phase_2_step_2_recorded_value[phase]
for expected_step in sorted(expected_steps.keys()):
put.assertIn(expected_step, actual, 'Phase {}: Missing step: {}'.format(phase, expected_step))
put.assertEqual(expected_steps[expected_step],
actual[expected_step],
'{}/{}'.format(phase, expected_step))
put.assertEqual(len(expected_steps),
len(actual),
'Actual number of recorded steps for phase {} must not exceed expected'.format(phase))
put.assertEqual(len(self.expected_phase_2_step_2_recorded_value),
len(actual_phase_2_step_2_recorded_value),
'Actual number of recorded phases must not exceed expected')
# To be sure that above code does not miss any case
put.assertEqual(self.expected_phase_2_step_2_recorded_value,
actual_phase_2_step_2_recorded_value,
'Recordings per phase and step')
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 _apply(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value, tuple,
'Expects a tuple of StringFragments')
asrt.matches_sequence(self._sequence_of_element_assertions).apply(put, value, message_builder)
def check_exception(self,
root_path: pathlib.Path,
actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteParseError)
expected_source = single_line_sequence(2, self.file_inclusion_line)
expectation = matches_suite_parse_error(
suite_file=asrt.equals(self.root_suite_based_at(root_path)),
maybe_section_name=asrt.equals(phase_names.SETUP.plain),
source=equals_line_sequence(expected_source),
source_location=equals_source_location_path(
SourceLocationPath(
SourceLocation(
expected_source,
self.root_suite_file,
),
[]
)
),
document_parser_exception=asrt.is_instance(sec_doc_exceptions.FileAccessError),
)
expectation.apply(put, actual)
def check_exception(self,
root_path: pathlib.Path,
actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteParseError)
expected_source = single_line_sequence(1, '[invalid-section]')
expectation = matches_suite_parse_error(
suite_file=asrt.equals(self.root_suite_based_at(root_path)),
maybe_section_name=asrt.is_none,
source=equals_line_sequence(expected_source),
source_location=equals_source_location_path(
SourceLocationPath(
SourceLocation(
expected_source,
Path('main.suite'),
),
[]
)
),
document_parser_exception=asrt.is_instance(sec_doc_exceptions.FileSourceError),
)
expectation.apply(put, actual)
def _apply(self, put: unittest.TestCase, value: Any,
message_builder: MessageBuilder):
msg = message_builder.apply('')
if value is None:
return
put.assertIsInstance(value, self.expected_type, msg)
self.value_assertion.apply(put, value, message_builder)
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, type(self.expected), message_builder.apply('type of CrossReferenceId'))
equality_checker = _CrossReferenceIdEqualsWhenClassIsEqual(self.expected, put, message_builder)
equality_checker.visit(value)
def _apply(self, put: unittest.TestCase, value: Any,
message_builder: MessageBuilder):
if self.description:
message_builder = message_builder.with_description(
self.description)
put.assertIsInstance(value, self.expected_type,
message_builder.msg_for_sub_component('type'))
self.value_assertion.apply(put, value, message_builder)
def _apply(self,
put: unittest.TestCase,
value: Any,
message_builder: MessageBuilder):
msg = message_builder.apply('')
put.assertIsNotNone(value, msg)
put.assertIsInstance(value, self.expected_type, msg)
self.value_assertion.apply(put, value, message_builder)
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 check_exception(self, root_path: pathlib.Path, actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteFileReferenceError)
put.assertEqual(str(self.root_suite_based_at(root_path)),
str(actual.suite_file),
'Source file that contains the error')
assert_equals_line_sequence(
put, single_line_sequence(2, 'does-not_exist.case'), actual.source)
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,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value, spe.ResultAndStderr)
put.assertEqual(self.exit_code,
value.result.exit_code,
message_builder.apply('Exit code'))
def check(put: unittest.TestCase, renderer: Callable[[T], Printable],
to_render: T, expected_rendition: str):
printable = renderer(to_render)
actual_rendition = _print_to_str(printable)
put.assertIsInstance(actual_rendition, str, 'rendition must be a str')
put.assertEqual(expected_rendition, actual_rendition)
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,
message_builder: MessageBuilder):
put.assertIsInstance(value, sh.SuccessOrHardError)
if not value.is_success:
from exactly_lib.util.simple_textstruct.file_printer_output import to_string
put.fail('\n'.join([
'Expected: success', 'Actual : hard_error: ' +
to_string.major_blocks(value.failure_message.render_sequence())
]))
def check_invalid_arguments(
self,
put: unittest.TestCase,
invalid_source: ParseSource,
):
with put.assertRaises(SingleInstructionInvalidArgumentException) as cx:
self.parser.parse(ARBITRARY_FS_LOCATION_INFO, invalid_source)
put.assertIsInstance(cx.exception.error_message, str, 'error message')
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 test_player_stackEvents(self):
destination = self.game.tilemap.layers['pnjs'].find('monstre')[0]
(dx, dy) = self.__calcule_delta(self.game.perso, destination)
self.game.perso.move(dx, dy)
self.game.player_stackEvents(self.game.perso,
self.game.monster_layer,
self.game.playerEvents)
TestCase.assertGreater(self, len(self.game.playerEvents), 0)
TestCase.assertIsInstance(self, self.game.playerEvents[0], Monster)
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 assert_is_list_of_act_phase_instructions(put: unittest.TestCase, x):
put.assertIsInstance(x, list,
'Invalid test input: Expecting list of ActPhaseInstruction:s. Found: ' + str(type(x)))
i = 0
for e in x:
put.assertIsInstance(e, ActPhaseInstruction,
'Invalid test input: Element [%d]. Expecting an ActPhaseInstruction:s. Found: %s' %
(i, type(e)))
i += 1
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: 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 _apply(self,
put: unittest.TestCase,
value: Any,
message_builder: MessageBuilder):
if self.description:
message_builder = message_builder.with_description(self.description)
put.assertIsInstance(value,
self.expected_type,
message_builder.msg_for_sub_component('type'))
self.value_assertion.apply(put, value, message_builder)
def check_exception(self, root_path: pathlib.Path, actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteParseError)
put.assertEqual(str(self.root_suite_based_at(root_path)),
str(actual.suite_file),
'Source file that contains the error')
assert_equals_line_sequence(
put,
single_line_sequence(1, '"starting but no closing double quote'),
actual.source)
def _assertions(self, unittest_case: unittest.TestCase,
actual: FailureInfo):
unittest_case.assertIsNotNone(actual, 'Failure info should be present')
unittest_case.assertIsInstance(
actual, ActPhaseFailureInfo,
'The failure is expected to be a {}'.format(
str(ActPhaseFailureInfo)))
assert isinstance(actual, ActPhaseFailureInfo)
self.assertions_(unittest_case, actual.phase_step.simple,
actual.failure_details)
def _apply(self,
put: unittest.TestCase,
value,
message_builder: MessageBuilder):
put.assertIsInstance(value, sh.SuccessOrHardError)
if not value.is_success:
put.fail('\n'.join([
'Expected: success',
'Actual : hard_error: ' + str(value.failure_message)
]))
def _assertions(self, unittest_case: unittest.TestCase,
actual: FailureInfo):
unittest_case.assertIsNotNone(actual, 'Failure info should be present')
unittest_case.assertIsInstance(
actual, InstructionFailureInfo,
'The failure is expected to be a {}'.format(
str(InstructionFailureInfo)))
assert isinstance(actual, InstructionFailureInfo)
self.assertions_(unittest_case, actual.phase_step,
actual.source_location.location.source,
actual.failure_details)
def check_exception(self,
root_path: pathlib.Path,
actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteParseError)
put.assertEqual(str(self.root_suite_based_at(root_path)),
str(actual.suite_file),
'Source file that contains the error')
assert_equals_line_sequence(put,
single_line_sequence(1, '"starting but no closing double quote'),
actual.source)
def _apply(
self,
put: unittest.TestCase,
value: PathSdv,
message_builder: MessageBuilder,
):
put.assertIsInstance(value, PathSdv)
path = value.resolve(self._symbols).value_of_any_dependency(
fake_tcds())
self._name.apply(put, path.name,
message_builder.for_sub_component('name'))
def check_exception(self,
root_path: pathlib.Path,
actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteFileReferenceError)
put.assertEqual(str(self.root_suite_based_at(root_path)),
str(actual.suite_file),
'Source file that contains the error')
assert_equals_line_sequence(put,
single_line_sequence(2, 'does-not_exist.suite'),
actual.source)
def _assertions(self,
unittest_case: unittest.TestCase,
actual: FailureInfo):
unittest_case.assertIsNotNone(actual,
'Failure info should be present')
unittest_case.assertIsInstance(actual, PhaseFailureInfo,
'The failure is expected to be a {}'.format(str(PhaseFailureInfo)))
assert isinstance(actual, PhaseFailureInfo)
self.assertions_(unittest_case,
actual.phase_step.simple,
actual.failure_details)
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 create_app(test: unittest.TestCase) -> App:
"""
Create an :py:class:`App <arobito.controlinterface.ControllerBackend.App>` instance
:param test: The currently running unit test case
:return: An instance of App
"""
app = App()
test.assertIsNotNone(app)
test.assertIsInstance(app, App)
return app
def assert_is_list_of_act_phase_instructions(put: unittest.TestCase, x):
put.assertIsInstance(
x, list,
'Invalid test input: Expecting list of ActPhaseInstruction:s. Found: '
+ str(type(x)))
i = 0
for e in x:
put.assertIsInstance(
e, ActPhaseInstruction,
'Invalid test input: Element [%d]. Expecting an ActPhaseInstruction:s. Found: %s'
% (i, type(e)))
i += 1
def _apply(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value, MatcherWTrace)
assert isinstance(value, MatcherWTrace) # Type info for IDE
expected = self._expected_equivalent.matches_w_trace(self._model_info.model)
actual = value.matches_w_trace(self._model_info.model)
put.assertEqual(expected.value,
actual.value,
message_builder.apply('model=' + self._model_info.description_of_model))
def _apply(self,
put: unittest.TestCase,
value,
message_builder: MessageBuilder):
put.assertIsInstance(value, svh.SuccessOrValidationErrorOrHardError)
if not value.is_success:
put.fail('\n'.join([
'Expected: ' + svh.SuccessOrValidationErrorOrHardErrorEnum.SUCCESS.name,
'Actual : {st}: {msg}'.format(
st=value.status.name,
msg=repr(value.failure_message))
]))
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 _check_sub_class_properties(self, put: unittest.TestCase,
actual: DependenciesAwareDdv,
tcds: TestCaseDs,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(actual, MultiDependenciesDdv,
message_builder.apply('class'))
assert isinstance(actual, MultiDependenciesDdv) # 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):
put.assertIsInstance(value, SymbolStringFragmentResolver)
assert isinstance(value, SymbolStringFragmentResolver) # Type info for IDE
put.assertFalse(value.is_string_constant,
'is_string_constant')
put.assertEqual(self.expected.symbol_name,
value.symbol_name,
'symbol_name')
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 _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):
put.assertIsInstance(value, StringFragmentResolver)
assert isinstance(value, StringFragmentResolver) # Type info for IDE
symbols = symbol_table_with_values_matching_references(self.expected.references)
tcds = fake_home_and_sds()
environment = PathResolvingEnvironmentPreOrPostSds(tcds, symbols)
assertions = [
asrt.sub_component('type_category',
lambda sfr: sfr.type_category,
asrt.equals(self.expected.type_category)
),
asrt.sub_component('data_value_type',
lambda sfr: sfr.data_value_type,
asrt.equals(self.expected.data_value_type)
),
asrt.sub_component('value_type',
lambda sfr: sfr.value_type,
asrt.equals(self.expected.value_type)
),
asrt.sub_component('is_string_constant',
lambda sfr: sfr.is_string_constant,
asrt.equals(self.expected.is_string_constant)
),
asrt.sub_component('resolve',
lambda sfr: sfr.resolve(environment.symbols),
equals_string_fragment(self.expected.resolve(environment.symbols))
),
asrt.sub_component('resolve_value_of_any_dependency',
lambda sfr: sfr.resolve_value_of_any_dependency(environment),
asrt.equals(
self.expected.resolve_value_of_any_dependency(environment))
),
]
if self.expected.is_string_constant:
assertions.append(
asrt.sub_component('string_constant',
lambda sfr: sfr.string_constant,
asrt.equals(self.expected.string_constant)
)
)
assertion = asrt.and_(assertions)
assertion.apply(put, value, message_builder)
def _apply(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value, StringResolver)
assert isinstance(value, StringResolver) # Type info for IDE
equals_symbol_references(self.symbol_references).apply_with_message(put,
value.references,
'symbol references')
environment = PathResolvingEnvironmentPreOrPostSds(fake_home_and_sds(),
self.symbols)
actual_resolved_prim_val = value.resolve_value_of_any_dependency(environment)
self.expected_resolved_primitive_value.apply_with_message(put, actual_resolved_prim_val,
'resolved primitive value')
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: 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))
