def test_possibility_to_have_sds_path_references_in_argument(self):
file_name_of_referenced_file = 'file-name.txt'
symbol = ConstantSuffixPathDdvSymbolContext(
'symbol_name', RelOptionType.REL_TMP, file_name_of_referenced_file)
executable = 'the-executable'
command_line = '{executable} {symbol}'.format(
executable=executable,
symbol=symbol.name__sym_ref_syntax,
)
arrangement = arrangement_w_tcds(
hds_contents=relativity_configurations.ATC_FILE.
populator_for_relativity_option_root__hds(
fs.DirContents([
fs.python_executable_file(
executable,
PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES
)
])),
symbol_table=symbol.symbol_table)
expectation = Expectation(
execute=eh_assertions.is_exit_code(0),
symbol_usages=asrt.matches_singleton_sequence(
symbol.reference_assertion__w_str_rendering),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=pr.stdout(
str_asrt.contains(file_name_of_referenced_file))),
)
check_execution(self, sut.actor(), [instr([command_line])],
arrangement, expectation)
def test_stdin_is_concatenation_of_model_and_program_stdin_WHEN_program_defines_single_stdin(
self):
# ARRANGE #
model_contents = '\n'.join(('the', 'contents', 'of', 'the', 'model'))
test_setup = SingleStdinOfProgramTestSetup(
self, exit_code=0, additional_stdin=model_contents)
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(
):
with self.subTest(pgm_and_args_case.name):
# ACT & ASSERT #
CHECKER.check__abs_stx(
self,
test_setup.program_w_stdin_syntax(
pgm_and_args_case.pgm_and_args),
Arrangement(
symbols=pgm_and_args_case.symbol_table,
process_execution=test_setup.
proc_exe_env__w_stdin_check,
atc_exe_input=AtcExeInputArr(
stdin_contents=model_contents, ),
tcds=TcdsArrangementPreAct(
tcds_contents=pgm_and_args_case.tcds, ),
),
Expectation(
symbol_usages=pgm_and_args_case.usages_assertion,
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_proc_result.
matches_proc_result(exit_code=asrt.equals(
test_setup.exit_code), )),
))
def runTest(self):
# ARRANGE #
source_file = fs.File.empty('source-file.src')
interpreter_with_non_existing_program_file = command_sdvs.for_executable_file(
path_sdvs.constant(
path_ddvs.rel_hds(relativity_configurations.INTERPRETER_FILE.relativity_option_rel_hds,
path_ddvs.constant_path_part('non-existing'))),
)
arrangement = arrangement_w_tcds(
hds_contents=relativity_configurations.ATC_FILE.populator_for_relativity_option_root__hds(
fs.DirContents([source_file])
)
)
expectation = Expectation(
validation=ValidationExpectationSvh.fails__pre_sds()
)
# ACT & ASSERT #
check_execution(self,
sut.actor(interpreter_with_non_existing_program_file),
[instr([source_file.name])],
arrangement,
expectation)
def runTest(self):
# ARRANGE #
stdin_from_act_exe_input = 'the stdin from the Act Execution Input (via [setup])'
stdin_defined_by_the_program = 'the stdin defined by the program'
test_setup = StdinCheckViaCopyToOutputFileTestSetup(
ProcOutputFile.STDOUT,
stdin_defined_for_program=[
ss_sdvs.const_str(stdin_defined_by_the_program)
])
full_stdin = stdin_defined_by_the_program + stdin_from_act_exe_input
# ACT & ASSERT #
CHECKER.check__abs_stx(
self,
test_setup.program_that_copies_stdin_syntax(),
Arrangement(
symbols=SymbolContext.symbol_table_of_contexts(
test_setup.symbols),
atc_exe_input=AtcExeInputArr(
stdin_contents=stdin_from_act_exe_input, ),
tcds=TcdsArrangementPreAct(),
),
Expectation(
symbol_usages=SymbolContext.usages_assertion_of_contexts(
test_setup.symbols),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_proc_result.
matches_proc_result(exit_code=asrt.equals(0),
stdout=asrt.equals(full_stdin))),
),
)
def test_executable_file_must_exist(self):
act_phase_instructions = [instr(['non-existing-executable'])]
arrangement = arrangement_w_tcds()
expectation = Expectation(
validation=ValidationExpectationSvh.fails__pre_sds())
check_execution(self, sut.actor(), act_phase_instructions, arrangement,
expectation)
def test_stdin_contains_model_contents_WHEN_program_do_not_define_stdin(
self):
# ARRANGE #
test_setup = SingleStdinOfProgramTestSetup(self, exit_code=0)
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(
):
with self.subTest(pgm_and_args_case.name):
# ACT & ASSERT #
CHECKER.check__abs_stx(
self, pgm_and_args_case.pgm_and_args,
Arrangement(
symbols=pgm_and_args_case.symbol_table,
process_execution=test_setup.
proc_exe_env__w_stdin_check,
atc_exe_input=AtcExeInputArr(
stdin_contents=test_setup.STRING_SOURCE_CONTENTS,
),
tcds=TcdsArrangementPreAct(
tcds_contents=pgm_and_args_case.tcds, ),
),
Expectation(
symbol_usages=pgm_and_args_case.usages_assertion,
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_proc_result.
matches_proc_result(exit_code=asrt.equals(
test_setup.exit_code), )),
))
def test_arguments_of_interpreter(self):
# ARRANGE #
exe_file = fs.python_executable_file(
'program-name',
py_programs.exit_with(0)
)
for case in VALIDATION_CASES:
with self.subTest(case.name):
interpreter_arguments = arguments_sdvs.ref_to_path_that_must_exist(
path_sdvs.of_rel_option_with_const_file_name(case.path_relativity,
'non-existing-file')
)
actor = sut.actor(
command_sdvs.for_executable_file(
path_sdvs.constant(path_ddvs.absolute_file_name(sys.executable)),
interpreter_arguments
)
)
act_instruction = instr([exe_file.name])
# ACT & ASSERT #
integration_check.check_execution(
self,
actor,
[act_instruction],
arrangement_w_tcds(
hds_contents=relativity_configurations.ATC_FILE.populator_for_relativity_option_root__hds(
fs.DirContents([exe_file])
)
),
Expectation(validation=case.expectation),
)
def runTest(self):
# ARRANGE #
source_file = fs.File.empty('source-file.src')
a_dir = fs.Dir.empty('a-dir')
interpreter_with_program_that_is_a_dir = command_sdvs.for_executable_file(
path_sdvs.constant(
path_ddvs.rel_hds(relativity_configurations.INTERPRETER_FILE.relativity_option_rel_hds,
path_ddvs.constant_path_part(a_dir.name))),
)
command_line = source_file
arrangement = arrangement_w_tcds(
hds_contents=hds_populators.multiple([
relativity_configurations.ATC_FILE.populator_for_relativity_option_root__hds(
fs.DirContents([source_file])
),
relativity_configurations.INTERPRETER_FILE.populator_for_relativity_option_root__hds(
fs.DirContents([a_dir])
),
])
)
expectation = Expectation(
validation=ValidationExpectationSvh.fails__pre_sds()
)
# ACT & ASSERT #
check_execution(self,
sut.actor(interpreter_with_program_that_is_a_dir),
[instr([command_line.name])],
arrangement,
expectation)
def runTest(self):
cwd_sub_dir_of_act = 'the-sub-dir-that-should-be-cwd'
def check_that_stdout_is_expected_cwd(
sds: SandboxDs) -> PostSdsExpectation:
return PostSdsExpectation(
sub_process_result_from_execute=asrt_proc_result.
matches_proc_result(stdout=asrt.equals(
str(sds.act_dir / cwd_sub_dir_of_act) + '\n')),
side_effects_on_files_after_execute=CwdSdsAssertion(
RelSdsOptionType.REL_ACT,
cwd_sub_dir_of_act,
))
with self.config.program_that_prints_cwd_to_stdout() as setup:
self._check(
setup.act_phase_instructions,
arrangement_w_tcds(
symbol_table=setup.symbols,
hds_contents=_hds_pop_of(setup),
post_sds_action=MkSubDirAndMakeItCurrentDirectory(
SdsSubDirResolverWithRelSdsRoot(
RelSdsOptionType.REL_ACT, cwd_sub_dir_of_act)),
act_exe_input=AtcExeInputArr(environ=setup.environ),
),
Expectation(
symbol_usages=setup.symbol_usages,
post_sds=check_that_stdout_is_expected_cwd,
))
def runTest(self):
# ARRANGE #
source_file = fs.File.empty('source-file.src')
python_interpreter_symbol = PathSymbolContext.of_sdv(
'PYTHON_INTERPRETER_SYMBOL',
path_sdvs.constant(
path_ddvs.absolute_path(pathlib.Path(sys.executable))))
interpreter_with_symbol_reference = command_sdvs.for_executable_file(
python_interpreter_symbol.reference_sdv__path_or_string(
relativity_configurations.INTERPRETER_FILE.relativity))
arrangement = arrangement_w_tcds(
symbol_table=python_interpreter_symbol.symbol_table,
hds_contents=relativity_configurations.ATC_FILE.
populator_for_relativity_option_root__hds(
fs.DirContents([source_file])))
expectation = Expectation(
symbol_usages=asrt.matches_singleton_sequence(
python_interpreter_symbol.reference_assertion__path_or_string),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_pr.sub_process_result(
exitcode=asrt.equals(0),
stdout=asrt.equals(''),
stderr=asrt.equals(''),
)),
)
# ACT & ASSERT #
check_execution(self, sut.actor(interpreter_with_symbol_reference),
[instr([])], arrangement, expectation)
def test_symbol_reference_on_command_line_SHOULD_be_reported_and_used_in_execution(
self):
symbol = StringConstantSymbolContext('symbol_name', 'symbol value')
string_to_print_template = 'constant and {symbol}'
expected_output_template = string_to_print_template + '\n'
shell_source_line = shell_commands.command_that_prints_to_stdout(
string_to_print_template.format(
symbol=symbol.name__sym_ref_syntax))
act_phase_instructions = [
instr([shell_command_source_line_for(shell_source_line)])
]
check_execution(
self,
sut.actor(),
act_phase_instructions,
arrangement_w_tcds(symbol_table=symbol.symbol_table),
Expectation(symbol_usages=asrt.matches_singleton_sequence(
symbol.reference_assertion__w_str_rendering),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=pr.stdout(
asrt.equals(
expected_output_template.format(
symbol=symbol.str_value))))),
)
def runTest(self):
# ARRANGE #
exit_code_from_program = 0
exe_file_in_path = fs.python_executable_file(
'the-program',
lines_content(py_program.exit_with_code(exit_code_from_program)),
)
program_symbol = StringConstantSymbolContext(
'PROGRAM_NAME_SYMBOL',
exe_file_in_path.name,
)
program_line = args.system_program_command_line(
program_symbol.name__sym_ref_syntax).as_str
with tmp_dir_in_path_with_files(DirContents([exe_file_in_path
])) as environ:
for source_case in valid_source_variants(program_line):
with self.subTest(source_case.name):
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[instr([program_line])],
arrangement_w_tcds(
symbol_table=program_symbol.symbol_table,
act_exe_input=AtcExeInputArr(environ=environ),
),
Expectation(
symbol_usages=asrt.matches_singleton_sequence(
program_symbol.
reference_assertion__string__w_all_indirect_refs_are_strings
),
execute=asrt_eh.is_exit_code(
exit_code_from_program)),
)
def test_symbol_usages_of_object_returned_by_parser_SHOULD_be_reported(
self):
# ARRANGE #
symbol_reference = NameAndValue(
'symbol_name',
reference_restrictions.is_any_type_w_str_rendering())
expected_symbol_references = [
SymbolReference(symbol_reference.name, symbol_reference.value)
]
actor = sut.ActorFromParts(
ParserWithConstantResult(
SymbolUserWithConstantSymbolReferences(
expected_symbol_references)),
sut.UnconditionallySuccessfulValidatorConstructor(),
_ExecutorConstructorForConstant(
UnconditionallySuccessfulExecutor()),
)
# ACT & ASSERT #
check_execution(
self, actor, [], arrangement_w_tcds(),
Expectation(symbol_usages=asrt.matches_sequence([
asrt_sym_ref.matches_reference_2(
symbol_reference.name,
data_restrictions_assertions.equals__w_str_rendering(
symbol_reference.value))
])))
def test_arguments_of_program_file(self):
# ARRANGE #
exe_file = fs.python_executable_file(
'program-name',
py_programs.exit_with(0)
)
actor = sut.actor(COMMAND_THAT_RUNS_PYTHON_PROGRAM_FILE)
for case in VALIDATION_CASES:
with self.subTest(case.name):
act_contents = ab.sequence__r([
ab.singleton(exe_file.name),
program_arguments.existing_file(
path_arguments.RelOptPathArgument('non-existing',
case.path_relativity)
)
])
act_instruction = instr([act_contents.as_str])
# ACT & ASSERT #
integration_check.check_execution(
self,
actor,
[act_instruction],
arrangement_w_tcds(
hds_contents=relativity_configurations.ATC_FILE.populator_for_relativity_option_root__hds(
fs.DirContents([exe_file])
)
),
Expectation(validation=case.expectation),
)
def test_symbol_value_with_space_SHOULD_be_given_as_single_argument_to_program(
self):
symbol = StringConstantSymbolContext('symbol_name',
'symbol value with space')
expected_output = lines_content([symbol.str_value])
executable_file_name = 'the-executable_file_name'
command_line = '{executable_file_name} {symbol}'.format(
executable_file_name=executable_file_name,
symbol=symbol.name__sym_ref_syntax,
)
arrangement = arrangement_w_tcds(
hds_contents=relativity_configurations.ATC_FILE.
populator_for_relativity_option_root__hds(
fs.DirContents([
fs.python_executable_file(
executable_file_name,
PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES
)
])),
symbol_table=symbol.symbol_table)
expectation = Expectation(
symbol_usages=asrt.matches_sequence(
[symbol.reference_assertion__w_str_rendering]),
execute=eh_assertions.is_exit_code(0),
post_sds=PostSdsExpectation.
constant(sub_process_result_from_execute=pr.stdout(
asrt.Equals(expected_output, 'CLI arguments, one per line'))),
)
check_execution(self, sut.actor(), [instr([command_line])],
arrangement, expectation)
def _check_with_exit_code(self, exit_code: int):
# ARRANGE #
result = SubProcessResult(
exitcode=exit_code,
stdout='output on stdout',
stderr='output on stderr',
)
command_py_program = py_program.program_that_prints_and_exits_with_exit_code(result)
py_file = fs.File(
'the-program.py',
command_py_program,
)
program_wo_transformation = ProgramSymbolContext.of_sdv(
'PROGRAM_SYMBOL',
program_sdvs.interpret_py_source_file_that_must_exist(
path_sdvs.of_rel_option_with_const_file_name(
RelOptionType.REL_HDS_CASE,
py_file.name,
)
)
)
source = args.program(
args.symbol_ref_command_line(program_wo_transformation.name),
transformation=TO_UPPER_CASE_TRANSFORMER.name__sym_ref_syntax)
symbols = [
program_wo_transformation,
TO_UPPER_CASE_TRANSFORMER,
]
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[instr(source.as_arguments.lines)],
arrangement_w_tcds(
symbol_table=SymbolContext.symbol_table_of_contexts(symbols),
hds_contents=hds_populators.contents_in(
RelHdsOptionType.REL_HDS_CASE,
DirContents([py_file]),
)
),
Expectation(
symbol_usages=SymbolContext.references_assertion_of_contexts(symbols),
execute=asrt_eh.is_exit_code(result.exitcode),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_proc_result.matches_proc_result(
exit_code=asrt.equals(result.exitcode),
stdout=asrt.equals(result.stdout.upper()),
stderr=asrt.equals(result.stderr),
)
)
),
)
def runTest(self):
# ARRANGE #
command_py_program = py_program.exit_with_code(0)
py_file = fs.File(
'the-program.py',
lines_content(command_py_program),
)
program_wo_transformation = ProgramSymbolContext.of_sdv(
'PROGRAM_SYMBOL',
program_sdvs.interpret_py_source_file_that_must_exist(
path_sdvs.of_rel_option_with_const_file_name(
RelOptionType.REL_HDS_CASE,
py_file.name,
)
)
)
error_message = 'error message from transformer'
transformer = StringTransformerPrimitiveSymbolContext(
'HARD_ERROR_TRANSFORMER',
string_transformers.model_access_raises_hard_error(error_message),
)
source = args.program(
args.symbol_ref_command_line(program_wo_transformation.name),
transformation=transformer.name__sym_ref_syntax)
symbols = [
program_wo_transformation,
transformer,
]
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[instr(source.as_arguments.lines)],
arrangement_w_tcds(
symbol_table=SymbolContext.symbol_table_of_contexts(symbols),
hds_contents=hds_populators.contents_in(
RelHdsOptionType.REL_HDS_CASE,
DirContents([py_file]),
)
),
Expectation(
symbol_usages=SymbolContext.references_assertion_of_contexts(symbols),
execute=asrt_eh.matches_hard_error(
asrt_failure_details.is_failure_message_matching__td(
asrt_text_doc.is_string_for_test_that_equals(error_message)
)
),
),
)
def runTest(self):
command_line = 'non-existing-file.src'
arrangement = arrangement_w_tcds()
expectation = Expectation(
validation=ValidationExpectationSvh.fails__pre_sds()
)
self._check(command_line,
arrangement,
expectation)
def test_executable_file_must_be_executable(self):
executable_file_name = 'existing-executable'
act_phase_instructions = [instr([executable_file_name])]
arrangement = arrangement_w_tcds(
hds_contents=relativity_configurations.ATC_FILE.
populator_for_relativity_option_root__hds(
fs.DirContents([File.empty(executable_file_name)])))
expectation = Expectation(
validation=ValidationExpectationSvh.fails__pre_sds())
check_execution(self, sut.actor(), act_phase_instructions, arrangement,
expectation)
def runTest(self):
actor = sut.actor(_command_for_non_existing_interpreter())
empty_source = []
check_execution(self,
actor,
empty_source,
arrangement_w_tcds(),
Expectation(
validation=ValidationExpectationSvh.fails__pre_sds()
)
)
def runTest(self):
# ARRANGE #
program_line = args.system_program_command_line(
'non-existing-system-program').as_str
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[instr([program_line])],
arrangement_w_tcds(),
Expectation.hard_error_from_execute(),
)
def runTest(self):
source_file = 'source-file.src'
command_line = source_file
arrangement = arrangement_w_tcds(
hds_contents=contents_in(RelHdsOptionType.REL_HDS_ACT, fs.DirContents([
Dir.empty(source_file)]))
)
expectation = Expectation(
validation=ValidationExpectationSvh.fails__pre_sds()
)
self._check(command_line,
arrangement,
expectation)
def runTest(self):
with self.config.program_that_exits_with_code(87) as setup:
self._check(
setup.act_phase_instructions,
arrangement_w_tcds(
symbol_table=setup.symbols,
hds_contents=_hds_pop_of(setup),
act_exe_input=AtcExeInputArr(environ=setup.environ),
),
Expectation(
symbol_usages=setup.symbol_usages,
execute=eh_assertions.is_exit_code(87),
))
def runTest(self):
for case in VALIDATION_CASES:
with self.subTest(case.name):
rel_conf = relativity_options.conf_rel_any(
case.path_relativity)
path_argument = rel_conf.path_argument_of_rel_name(
'name-of-non-existing-file')
act_phase_instructions = [instr([path_argument.as_str])]
integration_check.check_execution(
self,
self.conf.actor,
act_phase_instructions,
arrangement_w_tcds(),
Expectation(validation=case.expectation),
)
def runTest(self):
sub_dir_of_home = 'sub-dir'
dir_symbol = ConstantSuffixPathDdvSymbolContext('dir_symbol_name',
RelOptionType.REL_HDS_ACT,
sub_dir_of_home,
PATH_RELATIVITY_VARIANTS_FOR_FILE_TO_RUN)
source_file_name_symbol = StringConstantSymbolContext('source_file_name_symbol_name',
'the-source-file.py')
argument = 'argument_string'
expected_output = lines_content([argument])
command_line = '{dir}/{file_name} {argument} '.format(
dir=dir_symbol.name__sym_ref_syntax,
file_name=source_file_name_symbol.name__sym_ref_syntax,
argument=argument,
)
executable_file = fs.File(
source_file_name_symbol.str_value,
PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES)
arrangement = arrangement_w_tcds(
hds_contents=contents_in(RelHdsOptionType.REL_HDS_ACT, fs.DirContents([
fs.Dir(sub_dir_of_home, [executable_file])
])),
symbol_table=SymbolContext.symbol_table_of_contexts([
dir_symbol,
source_file_name_symbol,
])
)
expectation = Expectation(
symbol_usages=asrt.matches_sequence([
dir_symbol.reference_assertion__path_or_string,
source_file_name_symbol.reference_assertion__path_component,
]),
execute=eh_assertions.is_exit_code(0),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=pr.stdout(asrt.Equals(expected_output,
'CLI arguments, one per line'))
),
)
self._check(command_line,
arrangement,
expectation)
def runTest(self):
# ARRANGE #
symbol = ProgramSymbolContext.of_sdv(
'PROGRAM_SYMBOL',
program_sdvs.system_program(
string_sdvs.str_constant('non-existing-system-program')))
program_line = args.symbol_ref_command_line(symbol.name).as_str
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[instr([program_line])],
arrangement_w_tcds(symbol_table=symbol.symbol_table),
Expectation.hard_error_from_execute(
symbol_usages=symbol.usages_assertion),
)
def runTest(self):
stderr_output = 'output on stderr'
with self.config.program_that_prints_to_stderr(stderr_output) as setup:
self._check(
setup.act_phase_instructions,
arrangement_w_tcds(
symbol_table=setup.symbols,
hds_contents=_hds_pop_of(setup),
act_exe_input=AtcExeInputArr(environ=setup.environ),
),
Expectation(
symbol_usages=setup.symbol_usages,
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_proc_result.
matches_proc_result(stderr=asrt.equals(stderr_output +
'\n')))),
)
def runTest(self):
with self.config.program_that_sleeps_at_least(5) as setup:
self._check(
setup.act_phase_instructions,
arrangement_w_tcds(
symbol_table=setup.symbols,
hds_contents=_hds_pop_of(setup),
process_execution=ProcessExecutionArrangement(
process_execution_settings=proc_exe_env_for_test(
timeout_in_seconds=1,
environ=setup.environ,
))),
Expectation(
symbol_usages=setup.symbol_usages,
execute=eh_assertions.is_hard_error,
),
)
def test_multiple_symbol_references_in_executable(self):
sub_dir_of_home = 'sub-dir'
dir_symbol = ConstantSuffixPathDdvSymbolContext(
'dir_symbol_name', RelOptionType.REL_HDS_ACT, sub_dir_of_home,
PATH_RELATIVITY_VARIANTS_FOR_FILE_TO_RUN)
executable_file_name_symbol = StringConstantSymbolContext(
'executable_file_name_symbol_name', 'the-executable-file')
argument = 'argument_string'
expected_output = lines_content([argument])
command_line = '{dir}/{file_name} {argument} '.format(
dir=dir_symbol.name__sym_ref_syntax,
file_name=executable_file_name_symbol.name__sym_ref_syntax,
argument=argument,
)
executable_file = fs.python_executable_file(
executable_file_name_symbol.str_value,
PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES
)
arrangement = arrangement_w_tcds(
hds_contents=relativity_configurations.ATC_FILE.
populator_for_relativity_option_root__hds(
fs.DirContents([fs.Dir(sub_dir_of_home, [executable_file])])),
symbol_table=SymbolContext.symbol_table_of_contexts([
dir_symbol,
executable_file_name_symbol,
]))
expectation = Expectation(
symbol_usages=asrt.matches_sequence([
dir_symbol.reference_assertion__path_or_string,
executable_file_name_symbol.
reference_assertion__string__w_all_indirect_refs_are_strings,
]),
execute=eh_assertions.is_exit_code(0),
post_sds=PostSdsExpectation.
constant(sub_process_result_from_execute=pr.stdout(
asrt.Equals(expected_output, 'CLI arguments, one per line'))),
)
check_execution(self, sut.actor(), [instr([command_line])],
arrangement, expectation)
def runTest(self):
# ARRANGE #
source_w_relative_name_of_existing_file = args.interpret_py_source_file(
'program.py')
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[
instr(
source_w_relative_name_of_existing_file.as_arguments.lines)
],
arrangement_w_tcds(),
Expectation(validation=ValidationExpectationSvh.fails__pre_sds()),
)