def _check_cases_with_non_empty_file(self, get_assertion_part_function: Callable[ [ExpectationType, LineMatcherSdv], FileContentsAssertionPart], actual_file_contents: str, matcher_cases: Sequence[Case]): environment = fake_post_sds_environment() os_services = new_for_current_os() with string_source_factory() as source_factory: # This test is expected to not create files using the above object, # but to be sure, one is used that creates and destroys temporary files. with tmp_file_containing(actual_file_contents) as actual_file_path: for case in matcher_cases: for expectation_type in ExpectationType: with self.subTest(case=case.name, expectation_type=expectation_type): model = source_factory.of_file__poorly_described( actual_file_path) matcher_sdv = sdv_components.matcher_sdv_from_constant_primitive( case.matcher) assertion_part = get_assertion_part_function( expectation_type, matcher_sdv) # ACT # actual = assertion_part.check_and_return_pfh( environment, os_services, model) # ASSERT # pfh_assertion = pfh_expectation_type_config( expectation_type).main_result( case. expected_result_for_positive_expectation) pfh_assertion.apply_without_message(self, actual)
def __init__(self, pre_contents_population_action: TcdsAction = TcdsAction(), hds_contents: hds_populators.HdsPopulator = hds_populators.empty(), sds_contents: sds_populator.SdsPopulator = sds_populator.empty(), non_hds_contents: non_hds_populator.NonHdsPopulator = non_hds_populator.empty(), tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(), post_sds_population_action: TcdsAction = TcdsAction(), act_result_producer: ActResultProducer = ActResultProducerFromActResult(), os_services: OsServices = os_services_access.new_for_current_os(), process_execution_settings: ProcessExecutionSettings = ProcessExecutionSettings.null(), default_environ_getter: DefaultEnvironGetter = get_empty_environ, symbols: SymbolTable = None, fs_location_info: FileSystemLocationInfo = ARBITRARY_FS_LOCATION_INFO, ): super().__init__(pre_contents_population_action=pre_contents_population_action, sds_contents=sds_contents, hds_contents=hds_contents, non_hds_contents=non_hds_contents, tcds_contents=tcds_contents, post_sds_population_action=post_sds_population_action, os_services=os_services, process_execution_settings=process_execution_settings, default_environ_getter=default_environ_getter, symbols=symbols, fs_location_info=fs_location_info) self.act_result_producer = act_result_producer
def execute(self): # SETUP # with preserved_cwd(): with home_directory_structure() as hds: # ACT # partial_result = sut.execute( self._test_case(), ExecutionConfiguration( os_environ_getter, None, None, os_services_access.new_for_current_os(), sandbox_root_name_resolver.for_test(), 2**10), ConfPhaseValues(NameAndValue('the actor', self.__actor), hds), self._mk_settings_handler, self.__dbg_do_not_delete_dir_structure) # ASSERT # self.__partial_result = partial_result self._assertions() # CLEANUP # if not self.__dbg_do_not_delete_dir_structure and self.sds: if self.sds.root_dir.exists(): shutil.rmtree(str(self.sds.root_dir), ignore_errors=True) else: if self.sds: print(str(self.sds.root_dir))
def apply( self, put: unittest.TestCase, message_builder: MessageBuilder, primitive: Program, resolving_environment: FullResolvingEnvironment, input_: ProcOutputFile, ) -> ResultWithTransformationData: process_execution_settings = proc_exe_env_for_test( timeout_in_seconds=5) pgm_output_dir = resolving_environment.application_environment.tmp_files_space.new_path_as_existing_dir( ) execution_result = pgm_execution.make_transformed_file_from_output( pgm_output_dir, process_execution_settings, os_services_access.new_for_current_os(), resolving_environment.application_environment.tmp_files_space, input_, primitive) proc_exe_result = execution_result.process_result stderr_contents = misc_utils.contents_of( proc_exe_result.files.path_of_std(ProcOutputFile.STDERR)) stdout_contents = misc_utils.contents_of( proc_exe_result.files.path_of_std(ProcOutputFile.STDOUT)) result_of_transformation = misc_utils.contents_of( execution_result.path_of_file_with_transformed_contents) proc_result_data = SubProcessResult(proc_exe_result.exit_code, stdout_contents, stderr_contents) return ResultWithTransformationData(proc_result_data, result_of_transformation)
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()), _predefined_properties.new_empty()) default_case_configuration = processors.Configuration( test_case_definition, TestCaseHandlingSetup( ActPhaseSetup('recording actor', self._phase_config().actor(recording_media)), IDENTITY_PREPROCESSOR), os_services_access.new_for_current_os(), 2**10, 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 __init__( self, pre_contents_population_action: TcdsAction = TcdsAction(), hds_contents: hds_populators.HdsPopulator = hds_populators.empty(), sds_contents_before_main: sds_populator.SdsPopulator = sds_populator. empty(), non_hds_contents_before_main: non_hds_populator. NonHdsPopulator = non_hds_populator.empty(), tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(), os_services: OsServices = new_for_current_os(), process_execution_settings: ProcessExecutionSettings = ProcessExecutionSettings.null(), default_environ_getter: DefaultEnvironGetter = get_empty_environ, previous_phase: PreviousPhase = PreviousPhase.ASSERT, symbols: SymbolTable = None, fs_location_info: FileSystemLocationInfo = ARBITRARY_FS_LOCATION_INFO, ): super().__init__( pre_contents_population_action=pre_contents_population_action, hds_contents=hds_contents, sds_contents=sds_contents_before_main, non_hds_contents=non_hds_contents_before_main, tcds_contents=tcds_contents, os_services=os_services, process_execution_settings=process_execution_settings, default_environ_getter=default_environ_getter, symbols=symbols, fs_location_info=fs_location_info) self.previous_phase = previous_phase
def arrangement( pre_contents_population_action: TcdsAction = TcdsAction(), hds_contents: hds_populators.HdsPopulator = hds_populators.empty(), sds_contents_before_main: sds_populator.SdsPopulator = sds_populator.empty( ), non_hds_contents_before_main: non_hds_populator. NonHdsPopulator = non_hds_populator.empty(), tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(), act_result_producer: ActResultProducer = ActResultProducerFromActResult(), os_services: OsServices = new_for_current_os(), process_execution_settings: ProcessExecutionSettings = ProcessExecutionSettings.null(), default_environ_getter: DefaultEnvironGetter = get_empty_environ, symbols: SymbolTable = None, ) -> ArrangementPostAct: return ArrangementPostAct( pre_contents_population_action=pre_contents_population_action, hds_contents=hds_contents, sds_contents=sds_contents_before_main, non_hds_contents=non_hds_contents_before_main, tcds_contents=tcds_contents, act_result_producer=act_result_producer, os_services=os_services, process_execution_settings=process_execution_settings, default_environ_getter=default_environ_getter, symbols=symbols)
class TestIsExistingRegularFileAssertionPart(unittest.TestCase): the_os_services = oss.new_for_current_os() environment = fake_post_sds_environment() def test_model_is_returned_WHEN_file_is_existing_regular_file(self): # ARRANGE # assertion_part = sut.IsExistingRegularFileAssertionPart() existing_regular_file = File.empty('regular.txt') with tmp_dir(DirContents([existing_regular_file])) as path_of_existing_directory: path_of_existing_regular_file = path_of_existing_directory / existing_regular_file.name path_ddv = path_ddvs.absolute_path(path_of_existing_regular_file) path = path_ddv.value_of_any_dependency__d(fake_tcds()) model = sut.ComparisonActualFile(path, True) # ACT # actual = assertion_part.check(self.environment, self.the_os_services, model) # ASSERT # self.assertIs(model, actual) def test_PfhHardError_SHOULD_be_raised_WHEN_file_does_not_exist(self): # ARRANGE # assertion_part = sut.IsExistingRegularFileAssertionPart() # ACT & ASSERT # with self.assertRaises(PfhHardErrorException): path = pathlib.Path('a file that does not exist') assertion_part.check(self.environment, self.the_os_services, sut.ComparisonActualFile( described_path.new_primitive(path), True, )) def test_PfhHardError_SHOULD_be_raised_WHEN_file_does_exist_but_is_not_a_regular_file(self): # ARRANGE # assertion_part = sut.IsExistingRegularFileAssertionPart() # ACT & ASSERT # with tmp_dir() as path_of_existing_directory: with self.assertRaises(PfhHardErrorException): assertion_part.check(self.environment, self.the_os_services, sut.ComparisonActualFile( described_path.new_primitive(path_of_existing_directory), True, ) ) def test_no_exception_SHOULD_be_not_raised_WHEN_file_does_not_exist_but_file_does_not_need_to_be_verified(self): # ARRANGE # assertion_part = sut.IsExistingRegularFileAssertionPart() # ACT & ASSERT # path = pathlib.Path('a file that does not exist') assertion_part.check(self.environment, self.the_os_services, sut.ComparisonActualFile( described_path.new_primitive(path), False, ))
def new_processor( setup_phase_instructions: Dict[str, InstructionParser], test_case_processor_constructor: TestCaseProcessorConstructor, predefined_properties: PredefinedProperties) -> sut.Processor: test_case_definition = TestCaseDefinition( TestCaseParsingSetup(space_separator_instruction_name_extractor, instruction_setup(setup_phase_instructions), ActPhaseParser()), predefined_properties) default_configuration = processors.Configuration( test_case_definition, test_case_handling_setup_with_identity_preprocessor(), os_services_access.new_for_current_os(), 2**10, False, sandbox_dir_resolving.mk_tmp_dir_with_prefix('test-suite-')) return sut.Processor( default_configuration, suite_hierarchy_reading.Reader( suite_hierarchy_reading.Environment( SectionElementParserThatRaisesRecognizedSectionElementSourceError( ), test_case_definition.parsing_setup, default_configuration.default_handling_setup)), ExecutionTracingProcessingReporter(), enumeration.DepthFirstEnumerator(), test_case_processor_constructor, )
def __init__( self, pre_contents_population_action: TcdsAction = TcdsAction(), hds_contents: hds_populators.HdsPopulator = hds_populators.empty(), sds_contents_before_main: sds_populator.SdsPopulator = sds_populator. empty(), non_hds_contents: non_hds_populator. NonHdsPopulator = non_hds_populator.empty(), tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(), os_services: OsServices = os_services_access.new_for_current_os(), process_execution_settings: ProcessExecutionSettings = ProcessExecutionSettings.null(), default_environ_getter: DefaultEnvironGetter = get_empty_environ, settings_builder: Optional[SetupSettingsBuilder] = None, symbols: SymbolTable = None, fs_location_info: FileSystemLocationInfo = ARBITRARY_FS_LOCATION_INFO, ): super().__init__( pre_contents_population_action=pre_contents_population_action, hds_contents=hds_contents, sds_contents=sds_contents_before_main, non_hds_contents=non_hds_contents, tcds_contents=tcds_contents, os_services=os_services, process_execution_settings=process_execution_settings, default_environ_getter=default_environ_getter, symbols=symbols, fs_location_info=fs_location_info, ) self.initial_settings_builder = settings_handlers.builder_from_optional( settings_builder)
def test_main_method_arguments(self): # ARRANGE # the_environ = MappingProxyType({'the_env_var': 'the env var value'}) the_timeout = 69 the_os_services = os_services_access.new_for_current_os() def main_action_that_checks_arguments(environment: InstructionEnvironmentForPostSdsStep, instruction_settings: InstructionSettings, os_services: OsServices): self.assertIs(os_services, the_os_services, 'os_services') self.assertEqual(the_environ, environment.proc_exe_settings.environ, 'proc exe settings/environment') self.assertEqual(the_timeout, environment.proc_exe_settings.timeout_in_seconds, 'proc exe settings/timeout') self.assertEqual(the_environ, instruction_settings.environ(), 'instruction settings/environment') # ACT & ASSERT # self._check_source_and_exe_variants( ParserThatGives(instruction_embryo_that__phase_agnostic( main_initial_action=main_action_that_checks_arguments )), Arrangement.phase_agnostic( process_execution_settings=ProcessExecutionSettings(the_timeout, the_environ), os_services=the_os_services, ), MultiSourceExpectation.phase_agnostic(), )
def _check_cases_for_no_lines( self, get_assertion_part_function: Callable[ [ExpectationType, LineMatcherSdv], AssertionPart[StringSource, pfh.PassOrFailOrHardError]], expected_result_when_positive_expectation: PassOrFail): empty_file_contents = '' environment = fake_post_sds_environment() os_services = new_for_current_os() matchers = [ ('unconditionally true', MatcherWithConstantResult(True)), ('unconditionally false', MatcherWithConstantResult(False)), ] with string_source_factory() as source_factory: # This test is expected to not create files using the above object, # but to be sure, one is used that creates and destroys temporary files. with tmp_file_containing(empty_file_contents) as actual_file_path: for expectation_type in ExpectationType: for matcher_name, matcher in matchers: with self.subTest(expectation_type=expectation_type, matcher_name=matcher_name): model = source_factory.of_file__poorly_described( actual_file_path) matcher_sdv = sdv_components.matcher_sdv_from_constant_primitive( matcher) assertion_part = get_assertion_part_function( expectation_type, matcher_sdv) # ACT # actual = assertion_part.check_and_return_pfh( environment, os_services, model) # ASSERT # pfh_assertion = pfh_expectation_type_config( expectation_type).main_result( expected_result_when_positive_expectation) pfh_assertion.apply_without_message(self, actual)
def __init__(self, pre_contents_population_action: TcdsAction = TcdsAction(), hds_contents: hds_populators.HdsPopulator = hds_populators.empty(), sds_contents: sds_populator.SdsPopulator = sds_populator.empty(), non_hds_contents: non_hds_populator.NonHdsPopulator = non_hds_populator.empty(), tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(), os_services: OsServices = os_services_access.new_for_current_os(), process_execution_settings: ProcessExecutionSettings = proc_exe_env_for_test(), default_environ_getter: DefaultEnvironGetter = get_empty_environ, post_sds_population_action: TcdsAction = TcdsAction(), symbols: SymbolTable = None, fs_location_info: FileSystemLocationInfo = ARBITRARY_FS_LOCATION_INFO, ): super().__init__(hds_contents=hds_contents, process_execution_settings=process_execution_settings, default_environ_getter=default_environ_getter) self.pre_contents_population_action = pre_contents_population_action self.sds_contents = sds_contents self.non_hds_contents = non_hds_contents self.tcds_contents = tcds_contents self.post_sds_population_action = post_sds_population_action self.os_services = os_services self.process_execution_settings = process_execution_settings self.symbols = symbol_table_from_none_or_value(symbols) self.fs_location_info = fs_location_info
class TestAssertionPart(unittest.TestCase): the_os_services = oss.new_for_current_os() environment = fake_post_sds_environment() def test_return_pfh_pass_WHEN_no_exception_is_raised(self): # ARRANGE # assertion_part_that_not_raises = SuccessfulPartThatReturnsConstructorArgPlusOne() # ACT # actual = assertion_part_that_not_raises.check_and_return_pfh(self.environment, self.the_os_services, 1) # ASSERT # assertion = asrt_pfh.is_pass() assertion.apply_without_message(self, actual) def test_return_pfh_fail_WHEN_PfhFailException_is_raised(self): # ARRANGE # assertion_part_that_raises = PartThatRaisesFailureExceptionIfArgumentIsEqualToOne() # ACT # actual = assertion_part_that_raises.check_and_return_pfh(self.environment, self.the_os_services, 1) # ASSERT # assertion = asrt_pfh.is_fail( is_string_for_test( asrt.equals(PartThatRaisesFailureExceptionIfArgumentIsEqualToOne.ERROR_MESSAGE)) ) assertion.apply_without_message(self, actual)
def application_environment_for_test( tmp_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, ) -> ApplicationEnvironment: return ApplicationEnvironment(os_services_, process_execution_settings, tmp_file_space, mem_buff_size)
def __init__(self, source: ParseSource, act_phase_source_lines: List[str], hds_contents: hds_populators.HdsPopulator = hds_populators.empty(), os_services: OsServices = os_services_access.new_for_current_os(), ): self.hds_contents = hds_contents self.source = source self.act_phase_source_lines = act_phase_source_lines self.os_services = os_services
def test_main_method_arguments(self): # ARRANGE # the_environ = MappingProxyType({'an_env_var': 'an env var value'}) the_timeout = 72 the_os_services = os_services_access.new_for_current_os() setup_settings_cases = [ NArrEx( 'none', None, asrt.is_none, ), NArrEx( 'not none', SetupSettingsArr(the_environ), _IsSettingsBuilderWoStdinWEnviron(asrt.equals(the_environ)), ), ] for setup_settings_case in setup_settings_cases: def main_action_that_checks_arguments(environment: InstructionEnvironmentForPostSdsStep, instruction_settings: InstructionSettings, settings_builder: Optional[SetupSettingsBuilder], os_services: OsServices): self.assertIs(os_services, the_os_services, 'os_services') self.assertEqual(the_environ, environment.proc_exe_settings.environ, 'proc exe settings/environment') self.assertEqual(the_timeout, environment.proc_exe_settings.timeout_in_seconds, 'proc exe settings/timeout') self.assertEqual(the_environ, instruction_settings.environ(), 'instruction settings/environment') setup_settings_case.expectation.apply_with_message(self, settings_builder, 'setup settings passed to main') # ACT & ASSERT # self._check_source_and_exe_variants( ParserThatGives(instruction_embryo_that__setup_phase_aware( main_initial_action=main_action_that_checks_arguments )), Arrangement.setup_phase_aware( process_execution_settings=ProcessExecutionSettings(the_timeout, the_environ), setup_settings=setup_settings_case.arrangement, os_services=the_os_services, ), MultiSourceExpectation.setup_phase_aware( setup_settings=asrt.anything_goes(), ), )
def apply(self, environment: PathResolvingEnvironmentPreOrPostSds) -> ExecutionResultAndStderr: environment_builder = InstructionEnvironmentPostSdsBuilder.new_tcds( environment.tcds, process_execution_settings=ProcessExecutionSettings.with_environ(os.environ), ) env__post_sds = environment_builder.build_post_sds() settings = optionally_from_proc_exe_settings(None, env__post_sds.proc_exe_settings) return self.instruction_embryo.main( env__post_sds, settings, os_services_access.new_for_current_os(), )
def application_environment_with_existing_dir( os_services: OsServices = os_services_access.new_for_current_os(), process_execution_settings: ProcessExecutionSettings = ProcessExecutionSettings.null(), mem_buff_size: int = 2**10, ) -> ContextManager[ApplicationEnvironment]: with tempfile.TemporaryDirectory(prefix='exactly') as tmp_dir_name: yield application_environment_for_test( tmp_dir_file_space_for_test(Path(tmp_dir_name)), os_services, process_execution_settings, mem_buff_size, )
def _resolve_os_services() -> OsServices: try: return os_services_access.new_for_current_os() except os_services_access.OsServicesError as ex: def print_ex_msg(environment: Environment): printer = environment.std_file_printers.get(ProcOutputFile.STDERR) printer.write_line(ex.msg) raise _StartupError( ProcessResultReporterWithInitialExitValueOutput( exit_values.EXECUTION__INTERNAL_ERROR, ProcOutputFile.STDOUT, print_ex_msg))
def arrangement( self, pre_contents_population_action: TcdsAction = TcdsAction(), hds_contents: hds_populators.HdsPopulator = hds_populators.empty(), sds_contents_before_main: sds_populator. SdsPopulator = sds_populator.empty(), tcds_contents: tcds_populators.TcdsPopulator = tcds_populators. empty(), environ: Optional[Dict[str, str]] = None, default_environ_getter: DefaultEnvironGetter = get_empty_environ, os_services: OsServices = new_for_current_os(), symbols: SymbolTable = None): raise NotImplementedError()
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 configuration_for_instruction_set( instruction_set: InstructionsSetup) -> sut.Configuration: tc_parsing_setup = TestCaseParsingSetup( first_space_separated_string_extractor, instruction_set, ActPhaseParser()) tc_definition = TestCaseDefinition(tc_parsing_setup, _predefined_properties.new_empty()) tc_handling_setup = setup_with_null_act_phase_and_null_preprocessing() return sut.Configuration( tc_definition, tc_handling_setup, os_services_access.new_for_current_os(), 2**10, is_keep_sandbox=False, )
def app_env_for_freeze( self, put: unittest.TestCase, message_builder: MessageBuilder, ) -> ContextManager[ApplicationEnvironment]: default_os_services = os_services_access.new_for_current_os() os_services_w_check = os_services_access.new_for_cmd_exe( CommandExecutorWithMaxNumInvocations( put, 1, default_os_services.command_executor, message_builder.apply(''), )) return application_environment.application_environment_with_existing_dir( os_services_w_check)
def __init__( self, test_case: TestCase, actor: Actor, settings_handler: Optional[MkSetupSettingsHandler] = None, os_services: OsServices = os_services_access.new_for_current_os(), mem_buff_size: int = 2**10, timeout_in_seconds: Optional[int] = None, ): self.test_case = test_case self.actor = actor self.timeout_in_seconds = timeout_in_seconds self.settings_handler = settings_handlers.mk_from_optional( settings_handler) self.os_services = os_services self.mem_buff_size = mem_buff_size
def __init__( self, test_case: test_case_doc.TestCase, configuration_builder: ConfigurationBuilder, settings_handler: Optional[SetupSettingsHandler] = None, predefined_properties: PredefinedProperties = _predefined_properties. new_empty(), os_services: OsServices = os_services_access.new_for_current_os(), mem_buff_size: int = 2**10, ): self.test_case = test_case self.predefined_properties = predefined_properties self.configuration_builder = configuration_builder self.settings_handler = settings_handlers.from_optional( settings_handler) self.os_services = os_services self.mem_buff_size = mem_buff_size
def arrangement(self, pre_contents_population_action: TcdsAction = TcdsAction(), hds_contents: hds_populators.HdsPopulator = hds_populators.empty(), sds_contents_before_main: sds_populator.SdsPopulator = sds_populator.empty(), tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(), environ: Optional[Dict[str, str]] = None, default_environ_getter: DefaultEnvironGetter = get_empty_environ, os_services: OsServices = new_for_current_os(), symbols: SymbolTable = None): return ic.Arrangement(pre_contents_population_action=pre_contents_population_action, hds_contents=hds_contents, sds_contents_before_main=sds_contents_before_main, tcds_contents=tcds_contents, process_execution_settings=ProcessExecutionSettings.from_non_immutable(environ=environ), default_environ_getter=default_environ_getter, os_services=os_services, symbols=symbols)
def phase_agnostic( tcds: Optional[TcdsArrangement] = None, os_services: OsServices = os_services_access.new_for_current_os(), process_execution_settings: ProcessExecutionSettings = proc_exe_env_for_test(), default_environ_getter: DefaultEnvironGetter = get_empty_environ, symbols: Optional[SymbolTable] = None, fs_location_info: FileSystemLocationInfo = ARBITRARY_FS_LOCATION_INFO, ) -> 'Arrangement': return Arrangement( tcds, os_services, process_execution_settings, default_environ_getter, symbols, fs_location_info, None, )
def __init__(self, unittest_case: unittest.TestCase, dbg_do_not_delete_dir_structure=False, actor: Actor = None, default_environ_getter: DefaultEnvironGetter = os_environ_getter, environ: Optional[Mapping[str, str]] = None, os_services: OsServices = os_services_access.new_for_current_os(), timeout_in_seconds: Optional[int] = None, ): self.__unittest_case = unittest_case self.__dbg_do_not_delete_dir_structure = dbg_do_not_delete_dir_structure self.__full_result = None self.__sandbox_directory_structure = None self.__initial_hds_dir_path = None self.__actor = actor self.__os_services = os_services self.__default_environ_getter = default_environ_getter self.__environ = environ self.__timeout_in_seconds = timeout_in_seconds
def action(std_files: StdOutputFiles) -> PartialExeResult: exe_conf = ExecutionConfiguration( os_environ_getter, None, arrangement.timeout_in_seconds, os_services_access.new_for_current_os(), sandbox_root_name_resolver.for_test(), arrangement.mem_buff_size, exe_atc_and_skip_assertions=std_files) with home_directory_structure() as hds: conf_phase_values = ConfPhaseValues( NameAndValue('the actor', actor), hds) return sut.execute( arrangement.test_case_generator.test_case, exe_conf, conf_phase_values, MkSetupSettingsHandlerThatRecordsValidation( arrangement.test_case_generator.recorder).make, False, )