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 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))