def test_equals(self): test_cases = [ ( 'Plain string', string_sdvs.str_constant('string value'), empty_symbol_table(), ), ( 'String with reference', sdv_with_references([ SymbolReference( 'symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any())) ]), empty_symbol_table(), ), ] for test_case_name, string_value, symbol_table in test_cases: assert isinstance(string_value, StringSdv), 'Type info for IDE' with self.subTest(msg='{}::with checked references::{}'.format( sut.equals_string_sdv.__name__, test_case_name)): assertion = sut.equals_string_sdv(string_value) assertion.apply_with_message(self, string_value, test_case_name)
def test_pass(self): a_symbol = NameAndValue('symbol name', ASymbolTableValue('symbol value')) a_different_symbol = NameAndValue('a different symbol name', ASymbolTableValue('a different symbol value')) cases = [ ( 'empty table', frozenset(), empty_symbol_table(), ), ( 'table with a single value', {a_symbol.name}, SymbolTable({ a_symbol.name: a_symbol.value, }), ), ( 'table with a multiple values', {a_symbol.name, a_different_symbol.name}, SymbolTable({ a_symbol.name: a_symbol.value, a_different_symbol.name: a_different_symbol.value, }), ), ] for name, expected_keys, actual_symbol_table in cases: with self.subTest(name=name): # ARRANGE # assertion = sut.assert_symbol_table_keys_equals(expected_keys) # ACT # assertion.apply_without_message(self, actual_symbol_table)
def test_dissatisfied_restriction(self): # ARRANGE # cases = { ValueType.STRING: ValueType.LIST, ValueType.LIST: ValueType.PATH, ValueType.PATH: ValueType.INTEGER_MATCHER, ValueType.INTEGER_MATCHER: ValueType.FILE_MATCHER, ValueType.FILE_MATCHER: ValueType.FILES_MATCHER, ValueType.FILES_MATCHER: ValueType.STRING_SOURCE, ValueType.STRING_SOURCE: ValueType.STRING_MATCHER, ValueType.STRING_MATCHER: ValueType.STRING_TRANSFORMER, ValueType.STRING_TRANSFORMER: ValueType.PROGRAM, ValueType.PROGRAM: ValueType.FILES_CONDITION, ValueType.FILES_CONDITION: ValueType.FILES_SOURCE, ValueType.FILES_SOURCE: ValueType.STRING, } symbols = empty_symbol_table() for expected_value_type, unexpected_value_type in cases.items(): container_of_unexpected = self.value_type_2_symbol_value_context_of_type[unexpected_value_type].container with self.subTest(expected_element_type=str(expected_value_type), unexpected_element_type=str(unexpected_value_type)): restriction_to_check = sut.ValueTypeRestriction.of_single(expected_value_type) # ACT error_message = restriction_to_check.is_satisfied_by(symbols, 'symbol name', container_of_unexpected) # ASSERT # self.assertIsNotNone(error_message)
def test_symbol_without_references(self): # ARRANGE # symbol_name = 'the_symbol_name' symbol_definition = _symbol_definition( symbol_name, string.ARBITRARY_SYMBOL_VALUE_CONTEXT) definitions_resolver = _ConstantDefinitionsResolver( [symbol_definition]) report_generator = sut.IndividualReportGenerator( symbol_name, True, empty_symbol_table()) # ACT # report = report_generator.generate(definitions_resolver) blocks = report.blocks() # ASSERT # self.assertTrue(report.is_success, 'is success') expected_blocks = asrt.is_empty_sequence expected_blocks.apply_with_message(self, blocks, 'blocks') _rendered_blocks_are_major_blocks(self, blocks)
def test_dissatisfied_restriction(self): # ARRANGE # cases = { ValueType.STRING: ValueType.LIST, ValueType.LIST: ValueType.PATH, ValueType.PATH: ValueType.FILE_MATCHER, ValueType.FILE_MATCHER: ValueType.STRING_TRANSFORMER, ValueType.FILES_MATCHER: ValueType.FILE_MATCHER, ValueType.STRING_MATCHER: ValueType.STRING_TRANSFORMER, ValueType.STRING_TRANSFORMER: ValueType.STRING, ValueType.PROGRAM: ValueType.STRING_TRANSFORMER, } symbols = empty_symbol_table() for expected_value_type, unexpected_value_type in cases.items(): container_of_unexpected = container(self.value_type_2_resolver_of_type[unexpected_value_type]) with self.subTest(expected_element_type=str(expected_value_type), unexpected_element_type=str(unexpected_value_type)): restriction_to_check = sut.ValueTypeRestriction(expected_value_type) # ACT error_message = restriction_to_check.is_satisfied_by(symbols, 'symbol name', container_of_unexpected) # ASSERT # self.assertIsNotNone(error_message)
def test_pass(self): a_symbol = NameAndValue('symbol name', ASymbolTableValue('symbol value')) a_different_symbol = NameAndValue( 'a different symbol name', ASymbolTableValue('a different symbol value')) cases = [ ( 'empty table', frozenset(), empty_symbol_table(), ), ( 'table with a single value', {a_symbol.name}, SymbolTable({ a_symbol.name: a_symbol.value, }), ), ( 'table with a multiple values', {a_symbol.name, a_different_symbol.name}, SymbolTable({ a_symbol.name: a_symbol.value, a_different_symbol.name: a_different_symbol.value, }), ), ] for name, expected_keys, actual_symbol_table in cases: with self.subTest(name=name): # ARRANGE # assertion = sut.assert_symbol_table_keys_equals(expected_keys) # ACT # assertion.apply_without_message(self, actual_symbol_table)
def test_differs__relativity(self): # ARRANGE # expected = FileRefTestImpl(RelOptionType.REL_ACT, file_refs.constant_path_part('file-name')) actual = FileRefTestImpl(RelOptionType.REL_HOME_CASE, file_refs.constant_path_part('file-name')) assertion = sut.matches_file_ref_resolver(expected, asrt.ignore, empty_symbol_table()) # ACT & ASSERT # assert_that_assertion_fails(assertion, file_ref_resolvers.constant(actual))
def runTest(self): # ARRANGE # test_cases = [ (PathPartDdvAsFixedPath('file.txt'), empty_symbol_table(), 'file.txt'), ] tcds = fake_tcds() for path_suffix, symbol_table, expected_path_suffix in test_cases: with self.subTest(): path = self.config.path_suffix_2_path(path_suffix) assert isinstance(path, PathDdv) # ACT # if self.config.resolving_dependency is None: tested_path_msg = 'value_when_no_dir_dependencies' actual_path = path.value_when_no_dir_dependencies() elif self.config.exists_pre_sds: tested_path_msg = 'file_path_pre_sds' actual_path = path.value_pre_sds(tcds.hds) else: tested_path_msg = 'file_path_post_sds' actual_path = path.value_post_sds(tcds.sds) actual_path_pre_or_post_sds = path.value_of_any_dependency( tcds) # ASSERT # expected_relativity_root = self.config.tcds_2_relativity_root( tcds) expected_path = expected_relativity_root / expected_path_suffix self.assertEqual(str(expected_path), str(actual_path), tested_path_msg) self.assertEqual(str(expected_path), str(actual_path_pre_or_post_sds), 'file_path_pre_or_post_sds')
def test_differs__relativity(self): # ARRANGE # expected = PathDdvTestImpl(RelOptionType.REL_ACT, path_ddvs.constant_path_part('file-name')) actual = PathDdvTestImpl(RelOptionType.REL_HDS_CASE, path_ddvs.constant_path_part('file-name')) assertion = sut.matches_path_sdv(expected, asrt.ignore, empty_symbol_table()) # ACT & ASSERT # assert_that_assertion_fails(assertion, path_sdvs.constant(actual))
def runTest(self): # ARRANGE # test_cases = [ (PathPartAsFixedPath('file.txt'), empty_symbol_table(), 'file.txt' ), ] home_and_sds = fake_home_and_sds() for path_suffix, symbol_table, expected_path_suffix in test_cases: with self.subTest(): file_reference = self.config.path_suffix_2_file_ref(path_suffix) assert isinstance(file_reference, FileRef) # ACT # if self.config.resolving_dependency is None: tested_path_msg = 'value_when_no_dir_dependencies' actual_path = file_reference.value_when_no_dir_dependencies() elif self.config.exists_pre_sds: tested_path_msg = 'file_path_pre_sds' actual_path = file_reference.value_pre_sds(home_and_sds.hds) else: tested_path_msg = 'file_path_post_sds' actual_path = file_reference.value_post_sds(home_and_sds.sds) actual_path_pre_or_post_sds = file_reference.value_of_any_dependency(home_and_sds) # ASSERT # expected_relativity_root = self.config.home_and_sds_2_relativity_root(home_and_sds) expected_path = expected_relativity_root / expected_path_suffix self.assertEqual(str(expected_path), str(actual_path), tested_path_msg) self.assertEqual(str(expected_path), str(actual_path_pre_or_post_sds), 'file_path_pre_or_post_sds')
def _new_processor(self, recording_media: List[Recording], test_case_processor_constructor: TestCaseProcessorConstructor) -> sut.Processor: test_case_definition = TestCaseDefinition( TestCaseParsingSetup(space_separator_instruction_name_extractor, self._phase_config().instructions_setup(REGISTER_INSTRUCTION_NAME, recording_media), self._phase_config().act_phase_parser()), PredefinedProperties({}, empty_symbol_table())) default_case_configuration = processors.Configuration( test_case_definition, TestCaseHandlingSetup( ActPhaseSetup(self._phase_config().actor(recording_media)), IDENTITY_PREPROCESSOR), os_services.DEFAULT_ATC_OS_PROCESS_EXECUTOR, False, sandbox_dir_resolving.mk_tmp_dir_with_prefix('test-suite-') ) return sut.Processor(default_case_configuration, suite_hierarchy_reading.Reader( suite_hierarchy_reading.Environment( SectionElementParserThatRaisesUnrecognizedSectionElementSourceError(), test_case_definition.parsing_setup, default_case_configuration.default_handling_setup) ), ProcessingReporterThatDoesNothing(), enumeration.DepthFirstEnumerator(), test_case_processor_constructor, )
def test_differs__exists_pre_sds(self): # ARRANGE # expected = FileRefTestImpl(_EXISTS_PRE_SDS_RELATIVITY, file_refs.constant_path_part('file-name')) actual = FileRefTestImpl(_NOT_EXISTS_PRE_SDS_RELATIVITY, file_refs.constant_path_part('file-name')) assertion = sut.matches_file_ref_resolver(expected, asrt.ignore, empty_symbol_table()) # ACT & ASSERT # assert_that_assertion_fails(assertion, file_ref_resolvers.constant(actual))
def test_differs__exists_pre_sds(self): # ARRANGE # expected = PathDdvTestImpl(_EXISTS_PRE_SDS_RELATIVITY, path_ddvs.constant_path_part('file-name')) actual = PathDdvTestImpl(_NOT_EXISTS_PRE_SDS_RELATIVITY, path_ddvs.constant_path_part('file-name')) assertion = sut.matches_path_sdv(expected, asrt.ignore, empty_symbol_table()) # ACT & ASSERT # assert_that_assertion_fails(assertion, path_sdvs.constant(actual))
def __init__(self, symbol_references: list, source: ValueAssertion, symbol_table: SymbolTable = None): self.symbol_references = symbol_references self.source = source self.symbol_table = empty_symbol_table() if symbol_table is None else symbol_table
def test_fail(self): a_symbol = NameAndValue('symbol name', ASymbolTableValue('symbol value')) a_different_symbol = NameAndValue('a different symbol name', ASymbolTableValue('a different symbol value')) cases = [ ('table is empty', empty_symbol_table(), a_symbol.name, asrt.anything_goes(), ), ('table is singleton but contains a different name', SymbolTable({a_symbol.name: a_symbol.value}), a_different_symbol.name, asrt.anything_goes(), ), ('table is singleton with given name but value assertion fails', SymbolTable({a_symbol.name: a_symbol.value}), a_symbol.name, assert_string_value_equals(a_different_symbol.value.value) ), ('table contains more than one element', SymbolTable({a_symbol.name: a_symbol.value, a_different_symbol.name: a_different_symbol.value }), a_symbol.name, asrt.anything_goes(), ), ] for name, table, symbol_name, value_assertion in cases: with self.subTest(name=name): assertion = sut.assert_symbol_table_is_singleton(symbol_name, value_assertion) assert_that_assertion_fails(assertion, table)
def test_strip_trailing_space(self): arguments = ' expected-argument ' instruction_embryo = self._parse_arguments(arguments) symbols = empty_symbol_table() file_ref = instruction_embryo.dir_path_resolver.resolve(symbols) equals_path_part_string('expected-argument').apply_with_message(self, file_ref.path_suffix(), 'path_suffix')
def test_success_when_correct_number_of_arguments__escaped(self): arguments = '"expected argument"' instruction_embryo = self._parse_arguments(arguments) symbols = empty_symbol_table() file_ref = instruction_embryo.dir_path_resolver.resolve(symbols) equals_path_part_string('expected argument').apply_with_message(self, file_ref.path_suffix(), 'path_suffix')
def test_resolve_without_symbol_references(self): string_constant_1 = 'string constant 1' string_constant_2 = 'string constant 2' string_symbol = NameAndValue('string_symbol_name', 'string symbol value') cases = [ Case( 'no elements', resolver_to_check= sut.ListResolver([]), symbols= empty_symbol_table(), expected_resolved_value= lv.ListValue([]), ), Case( 'single constant element', resolver_to_check= sut.ListResolver([list_resolvers.str_element(string_constant_1)]), symbols= empty_symbol_table(), expected_resolved_value= lv.ListValue([string_value_of_single_string(string_constant_1)]), ), Case( 'multiple constant elements', resolver_to_check= sut.ListResolver([list_resolvers.str_element(string_constant_1), list_resolvers.str_element(string_constant_2)]), symbols= empty_symbol_table(), expected_resolved_value= lv.ListValue([string_value_of_single_string(string_constant_1), string_value_of_single_string(string_constant_2)]), ), Case( 'single string symbol reference element', resolver_to_check= sut.ListResolver([list_resolvers.symbol_element(su.symbol_reference(string_symbol.name))]), symbols= su.symbol_table_with_single_string_value(string_symbol.name, string_symbol.value), expected_resolved_value= lv.ListValue([string_value_of_single_string(string_symbol.value)]), ), ] self._check('resolve without symbol references', cases)
def test_WHEN_no_usages_to_validate_THEN_validation_ok( self): # ARRANGE # symbol_table = empty_symbol_table() symbol_usages = [] # ACT # actual = sut.validate_symbol_usages(symbol_usages, symbol_table) self.assertIsNone(actual, 'result should indicate ok')
def test_resolve_without_symbol_references(self): string_constant_1 = 'string constant 1' string_constant_2 = 'string constant 2' string_symbol = StringConstantSymbolContext('string_symbol_name', 'string symbol value') cases = [ Case( 'no elements', sdv_to_check= sut.ListSdv([]), symbols= empty_symbol_table(), expected_resolved_value= ListDdv([]), ), Case( 'single constant element', sdv_to_check= sut.ListSdv([list_sdvs.str_element(string_constant_1)]), symbols= empty_symbol_table(), expected_resolved_value= ListDdv([string_ddv_of_single_string(string_constant_1)]), ), Case( 'multiple constant elements', sdv_to_check= sut.ListSdv([list_sdvs.str_element(string_constant_1), list_sdvs.str_element(string_constant_2)]), symbols= empty_symbol_table(), expected_resolved_value= ListDdv([string_ddv_of_single_string(string_constant_1), string_ddv_of_single_string(string_constant_2)]), ), Case( 'single string symbol reference element', sdv_to_check= sut.ListSdv([list_sdvs.symbol_element(string_symbol.reference__w_str_rendering)]), symbols= string_symbol.symbol_table, expected_resolved_value= ListDdv([string_ddv_of_single_string(string_symbol.str_value)]), ), ] self._check('resolve without symbol references', cases)
def matches_resolved_value(expected_resolved_primitive_lines: list, symbol_references: list = None, symbols: SymbolTable = None) -> ValueAssertion: symbols = empty_symbol_table() if symbols is None else symbols symbol_references = [] if symbol_references is None else symbol_references return string_assertions.matches_primitive_string( asrt.equals(contents_str_from_lines(expected_resolved_primitive_lines)), symbol_references, symbols)
def test_WHEN_referenced_symbol_not_in_symbol_table_THEN_validation_error(self): # ARRANGE # symbol_table = empty_symbol_table() symbol_usage = SymbolReference('undefined', reference_restrictions__unconditionally_satisfied()) # ACT # actual = sut.validate_symbol_usage(symbol_usage, symbol_table) self.assertIsNotNone(actual, 'result should indicate error') self.assertIs(PartialControlledFailureEnum.VALIDATION_ERROR, actual.status)
def test_add(self): # ARRANGE # symbol = NameAndValue('the symbol name', ASymbolTableValue('the symbol value')) table = sut.empty_symbol_table() # ACT # table.add(sut.Entry(symbol.name, symbol.value)) # ASSERT # _assert_table_contains_single_value(self, table, symbol)
def test_WHEN_referenced_symbol_not_in_symbol_table_THEN_validation_error(self): # ARRANGE # symbol_table = empty_symbol_table() symbol_usage = su.SymbolReference('undefined', unconditionally_satisfied_reference_restrictions()) # ACT # actual = sut.validate_symbol_usage(symbol_usage, symbol_table) self.assertIsNotNone(actual, 'result should indicate error') self.assertIs(PartialControlledFailureEnum.VALIDATION_ERROR, actual.status)
def test_resolved_value(self): # ARRANGE # file_ref = FileRefTestImpl(RelOptionType.REL_TMP, file_refs.empty_path_part()) resolver = sut.FileRefConstant(file_ref) # ACT # actual = resolver.resolve(empty_symbol_table()) # ASSERT # assertion = equals_file_ref(file_ref) assertion.apply_without_message(self, actual)
def test_resolve_should_give_string_constant(self): # ARRANGE # string_constant = 'string constant' fragment = impl.ConstantStringFragmentSdv(string_constant) # ACT # actual = fragment.resolve(empty_symbol_table()) # ASSERT # assertion = equals_string_fragment_ddv( csv.ConstantFragmentDdv(string_constant)) assertion.apply_without_message(self, actual)
def test_resolved_value(self): # ARRANGE # path = PathDdvTestImpl(RelOptionType.REL_TMP, path_ddvs.empty_path_part()) sdv = sut.PathConstantSdv(path) # ACT # actual = sdv.resolve(empty_symbol_table()) # ASSERT # assertion = equals_path(path) assertion.apply_without_message(self, actual)
def test(self): cases = [ FailureOfDirectReference(ValueRestrictionFailure('error message')), FailureOfDirectReference(ValueRestrictionFailure('error message', 'how to fix')), ] for failure in cases: with self.subTest(msg=failure.error): actual = sut.error_message('checked_symbol', empty_symbol_table(), failure) self.assertIsInstance(actual, str)
def matches_resolved_value( expected_resolved_primitive_lines: Sequence[str], symbol_references: Optional[Sequence[SymbolReference]] = None, symbols: SymbolTable = None) -> Assertion[StringSdv]: symbols = empty_symbol_table() if symbols is None else symbols symbol_references = [] if symbol_references is None else symbol_references return exactly_lib_test.type_val_deps.types.string_.test_resources.sdv_assertions.matches_primitive_string( asrt.equals( contents_str_from_lines(expected_resolved_primitive_lines)), symbol_references, symbols)
def test_with_and_without_references(self): test_cases = [ ('Plain string', string_resolvers.str_constant('string value'), empty_symbol_table(), ), ('String with reference', resolver_with_references([SymbolReference('symbol_name', ReferenceRestrictionsOnDirectAndIndirect( AnyDataTypeRestriction()))]), empty_symbol_table(), ), ] for test_case_name, string_value, symbol_table in test_cases: assert isinstance(string_value, StringResolver), 'Type info for IDE' with self.subTest(msg='{}::with checked references::{}'.format(sut.equals_string_resolver.__name__, test_case_name)): assertion = sut.equals_string_resolver(string_value) assertion.apply_with_message(self, string_value, test_case_name)
def test(self): cases = [ FailureOfDirectReference(_new_em('error message')), FailureOfDirectReference(_new_em('error message', 'how to fix')), ] for failure in cases: with self.subTest(msg=failure.error): actual = sut.ErrorMessage('checked_symbol', empty_symbol_table(), failure) asrt_text_doc.assert_is_valid_text_renderer(self, actual)
def test_resolve(self): # ARRANGE # path_part = sut.PathPartResolverAsFixedPath('the file name') # ACT # symbols = st.empty_symbol_table() actual = path_part.resolve(symbols) # ASSERT # self.assertIsInstance(actual, PathPart) self.assertEqual('the file name', actual.value(), 'resolved file name')
def new_processor_with_no_symbols(registry: tr.Registry, test_case_processor_constructor: TestCaseProcessorConstructor) -> sut.Processor: return new_processor( { INSTR_DEFINE: tr.InstructionParserForDefine(), INSTR_REGISTER_EXISTENCE: tr.InstructionParserForRegistersExistenceOfSymbol(registry), } , test_case_processor_constructor, PredefinedProperties({}, empty_symbol_table()) )
def test_differs__symbol_references(self): # ARRANGE # file_ref = FileRefTestImpl(RelOptionType.REL_ACT, file_refs.constant_path_part('file-name')) actual = _FileRefResolverWithConstantFileRefAndSymbolReferences( file_ref, [SymbolReference('symbol_name', ReferenceRestrictionsOnDirectAndIndirect(AnyDataTypeRestriction()))]) assertion = sut.matches_file_ref_resolver(file_ref, asrt.matches_sequence([]), empty_symbol_table()) # ACT & ASSERT # assert_that_assertion_fails(assertion, actual)
def __init__(self, name: str, source: ParseSource, source_assertion: Assertion[ParseSource], references: Assertion[Sequence[SymbolReference]] = asrt.is_empty_sequence, symbols: SymbolTable = empty_symbol_table(), ): self.name = name self.source = source self.source_assertion = source_assertion self.references = references self.symbols = symbols
def test_WHEN_all_usages_are_valid_THEN_validation_ok( self): # ARRANGE # symbol_table = empty_symbol_table() valid_definition = StringSymbolContext.of_constant('symbol', 'value').definition valid__reference = SymbolReference('symbol', reference_restrictions__unconditionally_satisfied()) symbol_usages = [ valid_definition, valid__reference, ] # ACT # actual = sut.validate_symbol_usages(symbol_usages, symbol_table) self.assertIsNone(actual, 'result should indicate ok')
def test_differs__symbol_references(self): # ARRANGE # path = PathDdvTestImpl(RelOptionType.REL_ACT, path_ddvs.constant_path_part('file-name')) actual = PathSdvTestImplWithConstantPathAndSymbolReferences( path, [SymbolReference('symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))]) assertion = sut.matches_path_sdv(path, asrt.matches_sequence([]), empty_symbol_table()) # ACT & ASSERT # assert_that_assertion_fails(assertion, actual)
def test_WHEN_all_usages_are_valid_THEN_validation_ok( self): # ARRANGE # symbol_table = empty_symbol_table() valid_definition = symbol_of('symbol') valid__reference = su.SymbolReference('symbol', unconditionally_satisfied_reference_restrictions()) symbol_usages = [ valid_definition, valid__reference, ] # ACT # actual = sut.validate_symbol_usages(symbol_usages, symbol_table) self.assertIsNone(actual, 'result should indicate ok')
def __init__( self, path_ddv: PathDdv, expected_symbol_references: List[SymbolReference], symbol_for_value_checks: Optional[SymbolTable] = None, ): self.symbol_for_value_checks = symbol_for_value_checks if symbol_for_value_checks is None: self.symbol_for_value_checks = empty_symbol_table() self.path_ddv = path_ddv self.expected_symbol_references = expected_symbol_references if self.expected_symbol_references is None: self.expected_symbol_references = []
def test_satisfied_restriction(self): # ARRANGE # symbols = empty_symbol_table() for expected_element_type in TypeCategory: container_of_resolver = container(self.element_type_2_resolver_of_type[expected_element_type]) with self.subTest(element_type=str(expected_element_type)): restriction_to_check = sut.TypeCategoryRestriction(expected_element_type) # ACT error_message = restriction_to_check.is_satisfied_by(symbols, 'symbol name', container_of_resolver) # ASSERT # self.assertIsNone(error_message)
def test_list_constant(self): # ARRANGE # constant = ['a', 'b' 'c'] # ACT # actual = list_sdvs.from_str_constants(constant) # ASSERT # self.assertEqual([], actual.references, 'references') actual_value = actual.resolve(empty_symbol_table()) expected_value = AMultiDirDependentValue(resolving_dependencies=set(), get_value_when_no_dir_dependencies=do_return(constant), get_value_of_any_dependency=do_return(constant)) matches_multi_dir_dependent_value(expected_value).apply_with_message(self, actual_value, 'resolve value')
def test_satisfied_restriction__multi(self): # ARRANGE # symbols = empty_symbol_table() for expected_value_type in ValueType: container_of_sdv = self.value_type_2_symbol_value_context_of_type[expected_value_type].container with self.subTest(element_type=str(expected_value_type)): restriction_to_check = sut.ValueTypeRestriction([expected_value_type, ValueType.STRING]) # ACT error_message = restriction_to_check.is_satisfied_by(symbols, 'symbol name', container_of_sdv) # ASSERT # self.assertIsNone(error_message)
def test_WHEN_updating_a_copy_THEN_the_copy_SHOULD_be_updated_but_not_the_original(self): # ARRANGE # symbol = NameAndValue('the symbol name', ASymbolTableValue('the symbol value')) original_table = sut.empty_symbol_table() # ACT # copied_table = original_table.copy() copied_table.put(symbol.name, symbol.value) # ASSERT # _assert_table_contains_single_value(self, copied_table, symbol) _assert_table_is_empty(self, original_table)
def test_WHEN_2nd_element_fails_to_validate_THEN_validation_error(self): # ARRANGE # symbol_table = empty_symbol_table() valid_definition = symbol_of('name-of-definition') invalid__reference = su.SymbolReference('undefined', unconditionally_satisfied_reference_restrictions()) symbol_usages = [ valid_definition, invalid__reference, ] # ACT # actual = sut.validate_symbol_usages(symbol_usages, symbol_table) self.assertIsNotNone(actual, 'result should indicate error') self.assertIs(PartialControlledFailureEnum.VALIDATION_ERROR, actual.status)
def test_WHEN_2nd_element_fails_to_validate_THEN_validation_error(self): # ARRANGE # symbol_table = empty_symbol_table() valid_definition = StringSymbolContext.of_constant('name-of-definition', 'value').definition invalid__reference = SymbolReference('undefined', reference_restrictions__unconditionally_satisfied()) symbol_usages = [ valid_definition, invalid__reference, ] # ACT # actual = sut.validate_symbol_usages(symbol_usages, symbol_table) self.assertIsNotNone(actual, 'result should indicate error') self.assertIs(PartialControlledFailureEnum.VALIDATION_ERROR, actual.status)
def __init__(self, name: str, source: str, result: EquivalenceCheck, interval: PosNeg[Assertion[IntIntervalWInversion]], references: Assertion[Sequence[SymbolReference]] = asrt.is_empty_sequence, symbols: SymbolTable = empty_symbol_table(), ): self.name = name self.source = source self.result = result self.interval = interval self.references = references self.symbols = symbols
def _file_contents_cases(self) -> InvalidDestinationFileTestCasesData: file_contents_cases = [ NameAndValue( 'contents of here doc', here_document_contents_arguments(['contents']) ), NameAndValue( 'contents of string', string_contents_arguments('contents') ), ] return InvalidDestinationFileTestCasesData( file_contents_cases, empty_symbol_table())
def test_pass(self): # ARRANGE # test_cases = [ string_resolvers.str_constant('string'), string_resolvers.str_constant(''), ] restriction = vr.StringRestriction() symbols = empty_symbol_table() for value in test_cases: with self.subTest(msg='value=' + str(value)): container = data_symbol_utils.container(value) # ACT # actual = restriction.is_satisfied_by(symbols, 'symbol_name', container) # ASSERT # self.assertIsNone(actual)
def test_pass(self): # ARRANGE # test_cases = [ StringSymbolValueContext.of_constant('string'), StringSymbolValueContext.of_constant(''), ] restriction = sut.is_string() symbols = empty_symbol_table() for value in test_cases: with self.subTest(msg='value=' + str(value)): # ACT # actual = restriction.is_satisfied_by(symbols, 'symbol_name', value.container) # ASSERT # self.assertIsNone(actual)
def test_difference_in_relativity_root(self): symbols = empty_symbol_table() for relativity in _RELATIVITY_VARIANTS: for path_suffix in _PATH_SUFFIX_VARIANTS: test_case_descr = 'relativity:{}, path-suffix: {}'.format(relativity, type(path_suffix)) file_ref = FileRefTestImpl(relativity, path_suffix) file_ref_resolver = file_ref_resolvers.constant(file_ref) with self.subTest(msg=sut.equals_file_ref_resolver.__name__ + ' :: ' + test_case_descr): assertion = sut.equals_file_ref_resolver(file_ref_resolver) assertion.apply_without_message(self, file_ref_resolver) with self.subTest(msg=sut.matches_file_ref_resolver.__name__ + ' :: ' + test_case_descr): assertion = sut.matches_file_ref_resolver(file_ref, equals_symbol_references(file_ref_resolver.references), symbols) assertion.apply_without_message(self, file_ref_resolver)
def resolving_helper( symbols: Optional[SymbolTable] = None, tcds: TestCaseDs = fake_tcds(), file_space: DirFileSpace = DirFileSpaceThatMustNoBeUsed(), os_services_: OsServices = os_services_access.new_for_current_os(), process_execution_settings: ProcessExecutionSettings = ProcessExecutionSettings.null(), mem_buff_size: int = 2**10, ) -> LogicTypeResolvingHelper: return LogicTypeResolvingHelper( (symbols if symbols is not None else empty_symbol_table()), tcds, ApplicationEnvironment(os_services_, process_execution_settings, file_space, mem_buff_size), )
def test_fail__not_a_string(self): # ARRANGE # test_cases = [ file_ref_constant_resolver(), FileMatcherResolverConstantTestImpl(FileMatcherTestImpl()), ] restriction = vr.StringRestriction() symbols = empty_symbol_table() for value in test_cases: with self.subTest(msg='value=' + str(value)): container = data_symbol_utils.container(value) # ACT # actual = restriction.is_satisfied_by(symbols, 'symbol_name', container) # ASSERT # self.assertIsNotNone(actual, 'Result should denote failing validation')
def runTest(self): # ARRANGE # conf = self.configuration arguments_str = _exe_file_syntax_str(conf, 'file.exe', 'remaining args') source = ParseSource(arguments_str) # ACT # exe_file = parse_executable_file_path.parser().parse(source) # ASSERT # source_assertion = has_remaining_part_of_first_line('remaining args') source_assertion.apply_with_message(self, source, 'source after parse') symbols = empty_symbol_table() self._check_existence_pre_sds(exe_file, symbols) with tcds_with_act_as_curr_dir(symbols=symbols) as environment: self._check_file_path('file.exe', exe_file, environment) self._assert_does_not_pass_validation(exe_file, environment)
def test_fail_WHEN_type_category_is_not_data(self): # ARRANGE # test_cases = [ FileMatcherResolverConstantTestImpl(FileMatcherTestImpl()), StringTransformerResolverConstantTestImpl(FakeStringTransformer(), []), ] restriction = vr.AnyDataTypeRestriction() symbols = empty_symbol_table() for value in test_cases: with self.subTest(msg='value=' + str(value)): container = data_symbol_utils.container(value) # ACT # actual = restriction.is_satisfied_by(symbols, 'symbol_name', container) # ASSERT # self.assertIsNotNone(actual, 'Result should denote failing validation')
def test_difference_in_relativity_root(self): symbols = empty_symbol_table() for relativity in _RELATIVITY_VARIANTS: for path_suffix in _PATH_SUFFIX_VARIANTS: test_case_descr = 'relativity:{}, path-suffix: {}'.format(relativity, type(path_suffix)) path = PathDdvTestImpl(relativity, path_suffix) path_sdv = path_sdvs.constant(path) with self.subTest(msg=sut.equals_path_sdv.__name__ + ' :: ' + test_case_descr): assertion = sut.equals_path_sdv(path_sdv) assertion.apply_without_message(self, path_sdv) with self.subTest(msg=sut.matches_path_sdv.__name__ + ' :: ' + test_case_descr): assertion = sut.matches_path_sdv(path, equals_symbol_references__w_str_rendering( path_sdv.references), symbols) assertion.apply_without_message(self, path_sdv)
def test_any__fail_WHEN_type_is_wo_str_rendering(self): # ARRANGE # test_cases = [ file_matcher.ARBITRARY_SYMBOL_VALUE_CONTEXT, st_symbol_context.ARBITRARY_SYMBOL_VALUE_CONTEXT, ] restriction = sut.ArbitraryValueWStrRenderingRestriction.of_any() symbols = empty_symbol_table() for value in test_cases: with self.subTest(msg='value=' + str(value)): # ACT # actual = restriction.is_satisfied_by(symbols, 'symbol_name', value.container) # ASSERT # self.assertIsNotNone( actual, 'Result should denote failing validation')
def test_any__pass_WHEN_type_is_w_str_rendering(self): # ARRANGE # test_cases = [ string.ARBITRARY_SYMBOL_VALUE_CONTEXT, path.ARBITRARY_SYMBOL_VALUE_CONTEXT, list_.ARBITRARY_SYMBOL_VALUE_CONTEXT, ] restriction = sut.ArbitraryValueWStrRenderingRestriction.of_any() symbols = empty_symbol_table() for value in test_cases: with self.subTest(msg='value=' + str(value)): # ACT # actual = restriction.is_satisfied_by(symbols, 'symbol_name', value.container) # ASSERT # self.assertIsNone(actual)