def phase_agnostic_2( validation: ValidationAssertions = ValidationAssertions.all_passes(), main_result: Assertion[T] = asrt.anything_goes(), main_raises_hard_error: bool = False, symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence, symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(), main_side_effects_on_files: TcdsExpectation = TcdsExpectation(), main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(), proc_exe_settings: Assertion[ProcessExecutionSettings] = asrt.is_instance(ProcessExecutionSettings), instruction_settings: Assertion[InstructionSettings] = asrt.is_instance(InstructionSettings), instruction_environment: Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(), ) -> 'MultiSourceExpectation[T]': return MultiSourceExpectation.phase_agnostic( validation, main_result, main_raises_hard_error, symbol_usages, symbols_after_main, main_side_effects_on_files.sds, main_side_effects_on_files.tcds, main_side_effects_on_files.case_home, main_side_effect_on_environment_variables, proc_exe_settings, instruction_settings, instruction_environment, )
def setup_phase_aware( validation: ValidationAssertions = ValidationAssertions.all_passes(), main_result: Assertion[T] = asrt.anything_goes(), main_raises_hard_error: bool = False, symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence, symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(), main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(), side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(), side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(), main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(), proc_exe_settings: Assertion[ProcessExecutionSettings] = asrt.is_instance(ProcessExecutionSettings), instruction_settings: Assertion[InstructionSettings] = asrt.is_instance(InstructionSettings), instruction_environment: Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(), setup_settings: Assertion[Optional[SettingsBuilderAssertionModel]] = asrt.is_none, ) -> 'MultiSourceExpectation[T]': return MultiSourceExpectation( MainMethodType.SETUP_PHASE_AWARE, validation, main_result, main_raises_hard_error, symbol_usages, symbols_after_main, main_side_effects_on_sds, side_effects_on_tcds, side_effects_on_hds, main_side_effect_on_environment_variables, proc_exe_settings, instruction_settings, instruction_environment, setup_settings, )
def phase_agnostic( validation: ValidationAssertions = ValidationAssertions.all_passes(), main_result: Assertion[T] = asrt.anything_goes(), main_raises_hard_error: bool = False, main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(), side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(), side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(), main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(), proc_exe_settings: Assertion[ProcessExecutionSettings] = asrt.is_instance(ProcessExecutionSettings), instruction_settings: Assertion[InstructionSettings] = asrt.is_instance(InstructionSettings), instruction_environment: Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(), ) -> 'ExecutionExpectation[T]': return ExecutionExpectation( MainMethodType.PHASE_AGNOSTIC, validation, main_result, main_raises_hard_error, main_side_effects_on_sds, side_effects_on_tcds, side_effects_on_hds, main_side_effect_on_environment_variables, proc_exe_settings, instruction_settings, instruction_environment, asrt.is_none, )
def __init__(self, main_method_type: MainMethodType, validation: ValidationAssertions = ValidationAssertions.all_passes(), main_result: Assertion[T] = asrt.anything_goes(), main_raises_hard_error: bool = False, main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(), side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(), side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(), main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(), proc_exe_settings: Assertion[ProcessExecutionSettings] = asrt.is_instance(ProcessExecutionSettings), instruction_settings: Assertion[InstructionSettings] = asrt.is_instance(InstructionSettings), instruction_environment: Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(), setup_settings: Assertion[Optional[SettingsBuilderAssertionModel]] = asrt.is_none, ): self.main_method_type = main_method_type self.validation = validation self.main_result = main_result self.main_raises_hard_error = main_raises_hard_error self.proc_exe_settings = proc_exe_settings self.instruction_settings = instruction_settings self.main_side_effects_on_sds = main_side_effects_on_sds self.side_effects_on_tcds = side_effects_on_tcds self.side_effects_on_hds = side_effects_on_hds self.main_side_effect_on_environment_variables = main_side_effect_on_environment_variables self.instruction_application_environment = instruction_environment self.setup_settings = setup_settings
def __init__( self, validation: ValidationAssertions = ValidationAssertions.all_passes(), main_result: Assertion[OUTPUT] = asrt.anything_goes(), is_hard_error: Optional[Assertion[TextRenderer]] = None, ): self.validation = validation self.main_result = main_result self.is_hard_error = is_hard_error
def test_quoted_tokens(self): # ARRANGE # regex_str = '.* regex' matches_for_case_sensitive = [' regex', 'before regex after'] option_cases = [ option_case_for_no_option( _AssertPattern(regex_str, matching_strings=matches_for_case_sensitive, non_matching_string=' REGEX') ), option_case_for_ignore_case( _AssertPattern(regex_str, matching_strings=matches_for_case_insensitive(matches_for_case_sensitive), non_matching_string='regex') ), ] text_on_following_line = 'text on following line' source_cases = [ SourceCase( 'soft quotes', source= Arguments('{regex}'.format( regex=surrounded_by_soft_quotes(regex_str), )), source_assertion= assert_token_stream(is_null=asrt.is_true), ), SourceCase( 'hard quotes, and text on following line', source= Arguments('{regex}'.format( regex=surrounded_by_hard_quotes(regex_str), ), following_lines=[text_on_following_line]), source_assertion= assert_token_stream( remaining_source=asrt.equals('\n' + text_on_following_line)), ), ] # ACT & ASSERT # check_many(self, Arrangement(), source_cases, ExpectationExceptPattern( validation=ValidationAssertions.all_passes() ), option_cases, )
def test_symbol_references(self): # ARRANGE # star_string_symbol = StringSymbolContext.of_constant('STAR_SYMBOL', '* ') regex_str = '.* regex' regex_arg_str = '.{star}regex'.format( star=symbol_reference_syntax_for_name(star_string_symbol.name), ) matches_for_case_sensitive = [' regex', 'before regex after'] option_cases = [ option_case_for_no_option( _AssertPattern(regex_str, matching_strings=matches_for_case_sensitive, non_matching_string=' REGEX') ), option_case_for_ignore_case( _AssertPattern(regex_str, matching_strings=matches_for_case_insensitive(matches_for_case_sensitive), non_matching_string='regex') ), ] source_cases = [ SourceCase('single invalid star', Arguments(regex_arg_str), assert_token_stream(is_null=asrt.is_true) ), SourceCase('invalid stars at start of regex', Arguments(surrounded_by_soft_quotes(regex_arg_str)), assert_token_stream(is_null=asrt.is_true) ), ] arrangement = Arrangement( symbols=star_string_symbol.symbol_table ) expectation = ExpectationExceptPattern( references=asrt.matches_sequence([ is_reference_to__regex_string_part(star_string_symbol.name), ]), validation=ValidationAssertions.all_passes(), ) # ACT & ASSERT # check_many(self, arrangement, source_cases, expectation, option_cases, )
def __init__(self, pattern: Assertion[Pattern] = asrt.anything_goes(), token_stream: Assertion[TokenStream] = asrt.anything_goes(), validation: ValidationAssertions = ValidationAssertions.all_passes(), references: Assertion[Sequence[SymbolReference]] = asrt.is_empty_sequence, ): self.pattern = pattern self.references = references self.validation = validation self.token_stream = token_stream
def of_exe( validation: ValidationAssertions = ValidationAssertions.all_passes(), main_result: Assertion[OUTPUT] = asrt.anything_goes(), is_hard_error: Optional[Assertion[TextRenderer]] = None, ) -> 'PrimAndExeExpectation[PRIMITIVE, OUTPUT]': return PrimAndExeExpectation( ExecutionExpectation( validation=validation, main_result=main_result, is_hard_error=is_hard_error, ), prim_asrt__any, )
def __init__(self, main_method_type: MainMethodType, validation: ValidationAssertions = ValidationAssertions.all_passes(), main_result: Assertion[T] = asrt.anything_goes(), main_raises_hard_error: bool = False, symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence, symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(), main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(), side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(), side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(), main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(), proc_exe_settings: Assertion[ProcessExecutionSettings] = asrt.is_instance(ProcessExecutionSettings), instruction_settings: Assertion[InstructionSettings] = asrt.is_instance(InstructionSettings), instruction_environment: Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(), setup_settings: Assertion[Optional[SettingsBuilderAssertionModel]] = asrt.is_none, ): super().__init__( main_method_type, validation, main_result, main_raises_hard_error, main_side_effects_on_sds, side_effects_on_tcds, side_effects_on_hds, main_side_effect_on_environment_variables, proc_exe_settings, instruction_settings, instruction_environment, setup_settings, ) self.symbol_usages = symbol_usages self.symbols_after_main = symbols_after_main
def __init__(self, references: Assertion[Sequence[SymbolReference]] = asrt.is_empty_sequence, validation: ValidationAssertions = ValidationAssertions.all_passes(), ): self.references = references self.validation = validation
def test_here_document(self): # ARRANGE # star_string_symbol = StringSymbolContext.of_constant('STAR_SYMBOL', '*') regex_str = '.*' regex_source_line = '.' + symbol_reference_syntax_for_name(star_string_symbol.name) arrangement = Arrangement( symbols=star_string_symbol.symbol_table ) matches_for_case_sensitive = [] option_cases = [ option_case_for_no_option( _AssertPattern(regex_str + '\n', matching_strings=matches_for_case_sensitive, non_matching_string='missing new line') ), option_case_for_ignore_case( _AssertPattern(regex_str + '\n', matching_strings=matches_for_case_insensitive(matches_for_case_sensitive), non_matching_string='missing new line') ), ] text_on_following_line = 'text on following line' here_doc_argument = here_document([regex_source_line]) source_cases = [ SourceCase( 'end of file after HD', source= here_doc_argument, source_assertion= assert_token_stream(remaining_part_of_current_line=asrt.equals(''), remaining_source=asrt.equals('')), ), SourceCase( 'followed by more lines', source= here_doc_argument.followed_by_lines([text_on_following_line]), source_assertion= assert_token_stream(remaining_part_of_current_line=asrt.equals(''), remaining_source=asrt.equals('\n' + text_on_following_line)), ), ] expectation = ExpectationExceptPattern( references=asrt.matches_sequence([ is_reference_to__regex_string_part(star_string_symbol.name), ]), validation=ValidationAssertions.all_passes(), ) # ACT & ASSERT # check_many(self, arrangement, source_cases, expectation, option_cases, )
def test_unquoted_tokens(self): # ARRANGE # regex_str = 'a.*regex' matches_for_case_sensitive = ['aBCregex', 'aBCregex and more'] option_cases = [ option_case_for_no_option( _AssertPattern(regex_str, matching_strings=matches_for_case_sensitive, non_matching_string='AbcREGEX') ), option_case_for_ignore_case( _AssertPattern(regex_str, matching_strings=matches_for_case_insensitive(matches_for_case_sensitive), non_matching_string='Abc') ), ] text_on_following_line = 'text on following line' def _arg(format_string: str) -> str: return format_string.format( regex=regex_str) source_cases = [ SourceCase( 'REG-EX is only source', source= Arguments(_arg('{regex}')), source_assertion= assert_token_stream(is_null=asrt.is_true), ), SourceCase( 'REG-EX is followed by a token', source= Arguments(_arg('{regex} following_token')), source_assertion= assert_token_stream( is_null=asrt.is_false, remaining_part_of_current_line=asrt.equals('following_token')), ), SourceCase( 'REG-EX is only element on current line, but followed by more lines', source= Arguments(_arg('{regex}'), following_lines=[text_on_following_line]), source_assertion= assert_token_stream( is_null=asrt.is_false, remaining_part_of_current_line=asrt.equals(''), remaining_source=asrt.equals('\n' + text_on_following_line)), ), ] # ACT & ASSERT # check_many(self, Arrangement(), source_cases, ExpectationExceptPattern( validation=ValidationAssertions.all_passes() ), option_cases, )