def arguments_cases() -> Sequence[NameAndValue[Sequence[ArgumentAbsStx]]]:
return [
NameAndValue('broken argument syntax due to missing end quote / soft',
[
ArgumentOfRichStringAbsStx.of_str(
QUOTE_CHAR_FOR_TYPE[QuoteType.SOFT] + 'argument')
]),
NameAndValue('broken argument syntax due to missing end quote / hard',
[
ArgumentOfRichStringAbsStx.of_str(
QUOTE_CHAR_FOR_TYPE[QuoteType.HARD] + 'argument')
]),
]
def _check_failing_validation___for_relativity(
self, missing_file_relativity: RelOptionType):
relativity_conf = relativity_options.conf_rel_any(
missing_file_relativity)
invalid_argument_syntax = ArgumentOfExistingPathAbsStx(
relativity_conf.path_abs_stx_of_name('non-existing-file'))
arguments_cases = [
NameAndValue(
'1st argument fails validation',
[invalid_argument_syntax],
),
NameAndValue(
'2nd argument fails validation',
[
ArgumentOfRichStringAbsStx.of_str('valid1'),
invalid_argument_syntax,
ArgumentOfRichStringAbsStx.of_str('valid2')
],
),
]
for pgm_and_args_case in pgm_and_args_cases.cases__w_argument_list__excluding_program_reference(
):
for arguments_case in arguments_cases:
pgm_w_args = PgmAndArgsWArgumentsAbsStx(
pgm_and_args_case.pgm_and_args, arguments_case.value)
with self.subTest(pgm_and_args=pgm_and_args_case.name,
arguments=arguments_case.name):
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
pgm_w_args,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
pgm_and_args_case.symbols),
tcds_contents=pgm_and_args_case.tcds,
),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
pgm_and_args_case.symbols),
primitive=asrt.anything_goes(),
execution=ExecutionExpectation(
validation=
FAILING_VALIDATION_ASSERTION_FOR_PARTITION[
relativity_conf.
directory_structure_partition], )),
)
def run_test(self):
def resolve_validator_that_fails_pre_sds(
symbols: SymbolTable) -> DdvValidator:
return ConstantDdvValidator.of_pre_sds(
asrt_text_doc.new_single_string_text_for_test('err msg'))
referenced_system_program_sdv_w_invalid_arguments = program_sdvs.system_program(
string_sdvs.str_constant('valid-system-program'),
ArgumentsSdv(list_sdvs.from_str_constant('the arg'),
[resolve_validator_that_fails_pre_sds]))
valid_program_symbol = ProgramSymbolContext.of_sdv(
'VALID_PROGRAM', referenced_system_program_sdv_w_invalid_arguments)
argument_syntax = ArgumentOfRichStringAbsStx.of_str('valid-arg')
reference_and_additional_invalid_argument = self.source_to_parse(
valid_program_symbol.name,
[argument_syntax],
)
# ACT & ASSERT #
self.integration_checker(
).check__abs_stx__layouts__source_variants__wo_input(
self.put,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
reference_and_additional_invalid_argument,
arrangement_w_tcds(symbols=valid_program_symbol.symbol_table, ),
MultiSourceExpectation.of_const(
symbol_references=valid_program_symbol.references_assertion,
primitive=asrt.anything_goes(),
execution=ExecutionExpectation(
validation=validation.ValidationAssertions.
pre_sds_fails__w_any_msg(), )),
)
def test_existing_file(self):
arguments = _python_executable([
ArgumentOfRichStringAbsStx.of_str('remaining'),
ArgumentOfRichStringAbsStx.of_str('args')
])
expectation_on_exe_file = ExpectationOnExeFile(
path_ddv=path_ddvs.absolute_file_name(sys.executable),
expected_symbol_references=[],
)
validator_expectation = validation.Expectation.passes_all()
self._check__abs_stx(
arguments,
expected_source_after_parse=has_remaining_part_of_first_line__re(
'remaining[ \t]+args'),
expectation_on_exe_file=expectation_on_exe_file,
validator_expectation=validator_expectation,
)
def runTest(self):
# ARRANGE #
arguments = ['arg']
str_src_contents = 'the_str_src_contents'
stdin_syntax = str_src_abs_stx.StringSourceWithinParensAbsStx(
str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
str_src_contents))
transformer_symbol = StringTransformerPrimitiveSymbolContext(
'TRANSFORMER', string_transformers.to_uppercase())
for pgm_and_args_case in pgm_and_args_cases.cases__w_argument_list__including_program_reference(
):
program_w_stdin = FullProgramAbsStx(
PgmAndArgsWArgumentsAbsStx(
pgm_and_args_case.pgm_and_args,
[
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments
],
),
stdin=stdin_syntax,
transformation=transformer_symbol.abstract_syntax,
)
symbols = list(pgm_and_args_case.symbols) + [transformer_symbol]
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=pgm_and_args_case.expected_command_driver(env),
arguments=asrt.equals(arguments),
),
stdin=asrt.matches_singleton_sequence(
asrt_str_src.matches__str(
asrt.equals(str_src_contents), )),
transformer=asrt.matches_singleton_sequence(
asrt.is_(transformer_symbol.primitive)),
)
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
program_w_stdin,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbols),
tcds_contents=pgm_and_args_case.tcds,
),
MultiSourceExpectation(
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
primitive=expected_program,
),
sub_test_identifiers={'command': pgm_and_args_case.name})
def test_string_token(self):
# ARRANGE #
plain_string = 'plain'
symbol_name = 'symbol_name'
string_symbol = StringSymbolContext.of_arbitrary_value(symbol_name)
cases = [
Case.of(
'plain string',
ArgumentOfRichStringAbsStx.of_str(plain_string),
ARRANGEMENT__NEUTRAL,
Expectation(
elements=[list_sdvs.str_element(plain_string)],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of(
'continuation token followed by plain string on next line',
ContinuationTokenFollowedByArgumentAbsStx(
ArgumentOfRichStringAbsStx.of_str(plain_string)),
ARRANGEMENT__NEUTRAL,
Expectation(
elements=[list_sdvs.str_element(plain_string)],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of(
'symbol reference',
ArgumentOfSymbolReferenceAbsStx(symbol_name),
Arrangement(string_symbol.symbol_table),
Expectation(
elements=[
list_sdvs.symbol_element(
reference_to__on_direct_and_indirect(symbol_name))
],
validators=asrt.is_empty_sequence,
references=asrt.matches_sequence(
[string_symbol.reference_assertion__w_str_rendering]),
)),
]
# ACT & ASSERT #
_test_cases_w_source_variants(self, cases)
def runTest(self):
instruction_argument = PgmAndArgsWArgumentsAbsStx(
self.configuration.executable,
[
ArgumentOfRichStringAbsStx.of_str('arg1'),
ArgumentOfRichStringAbsStx.of_str('-arg2'),
],
)
utils.check__abs_stx(
self,
instruction_argument,
utils.Arrangement(tcds_pop.empty()),
utils.Expectation(
path_ddv=self.configuration.path_ddv,
expected_symbol_references=self.configuration.
expected_symbol_references,
source=has_remaining_part_of_first_line__re('arg1[ \t]+-arg2'),
validation_result=self.configuration.validation_result,
),
)
def _check(
self,
command_driver: CommandDriverSdvCase,
arguments_of_referenced_command: List[str],
accumulated_arguments_of_referenced_program: List[str],
additional_argument: List[str],
):
# ARRANGE #
all_arguments = (arguments_of_referenced_command +
accumulated_arguments_of_referenced_program +
additional_argument)
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=command_driver.expected_command_driver(env),
arguments=asrt.equals(all_arguments)),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
referenced_program_symbol = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM',
command_program_sdv.ProgramSdvForCommand(
CommandSdv(
command_driver.command_driver,
ArgumentsSdv.new_without_validation(
list_sdvs.from_str_constants(
arguments_of_referenced_command))),
AccumulatedComponents.of_arguments(
ArgumentsSdv.new_without_validation(
list_sdvs.from_str_constants(
accumulated_arguments_of_referenced_program)))))
source_to_parse = self.source_to_parse(
referenced_program_symbol.name,
[
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in additional_argument
],
)
# ACT & ASSERT #
self.integration_checker().check__abs_stx__wo_input(
self.put,
source_to_parse,
command_driver.mk_arrangement(
referenced_program_symbol.symbol_table),
Expectation(
parse=ParseExpectation(
symbol_references=referenced_program_symbol.
references_assertion, ),
primitive=expected_program,
),
)
def test_non_existing_file(self):
non_existing_file_path = non_existing_absolute_path(
'/this/file/is/assumed/to/not/exist')
non_existing_file_path_str = str(non_existing_file_path)
arguments = ProgramOfExecutableFileCommandLineAbsStx(
PathStringAbsStx.of_plain_str(non_existing_file_path_str), [
ArgumentOfRichStringAbsStx.of_str('remaining'),
ArgumentOfRichStringAbsStx.of_str('args')
])
expectation_on_exe_file = ExpectationOnExeFile(
path_ddv=path_ddvs.absolute_file_name(non_existing_file_path_str),
expected_symbol_references=[],
)
validator_expectation = validation.Expectation(passes_pre_sds=False,
passes_post_sds=True)
self._check__abs_stx(
arguments,
expected_source_after_parse=has_remaining_part_of_first_line__re(
'remaining[ \t]+args'),
expectation_on_exe_file=expectation_on_exe_file,
validator_expectation=validator_expectation)
def test_without_reference_to_existing_file(self):
# ARRANGE #
abstract_syntax = RawSystemCommandLineAbsStx.of_str(
'program_name',
[ArgumentOfRichStringAbsStx.of_str('argument-that-is-not-a-file')])
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
abstract_syntax,
arrangement_wo_tcds(),
MultiSourceExpectation(execution=ExecutionExpectation(
validation=validation.ValidationAssertions.all_passes())),
)
def program_that_checks_stdin__syntax(
self,
program_stdin: str,
additional_expected_stdin: str = '',
) -> FullProgramAbsStx:
expected_contents_arg_syntax = ArgumentOfRichStringAbsStx.of_str(
program_stdin + additional_expected_stdin, QuoteType.HARD)
checker_pgm_syntax = ProgramOfPythonInterpreterAbsStx.of_execute_python_src_file(
self._SRC_FILE_REL_CONF.path_abs_stx_of_name(
self._CHECKER_PROGRAM_FILE_NAME),
[expected_contents_arg_syntax],
)
return FullProgramAbsStx(
checker_pgm_syntax,
stdin=StringSourceOfStringAbsStx.of_str_hard(program_stdin))
def runTest(self):
# ARRANGE #
cases = [
NameAndValue(
'empty source',
RawSystemCommandLineAbsStx.of_str(''),
),
NameAndValue(
'invalid program name - broken syntax due to missing end quote',
RawSystemCommandLineAbsStx.of_str(
QUOTE_CHAR_FOR_TYPE[QuoteType.SOFT] +
'valid_program_name'),
),
NameAndValue(
'invalid argument - broken syntax due to missing end quote',
RawSystemCommandLineAbsStx.of_str('valid_program_name', [
ArgumentOfRichStringAbsStx.of_str(
QUOTE_CHAR_FOR_TYPE[QuoteType.SOFT] + 'argument')
])),
]
checker = parse_checker.Checker(
ParserAsLocationAwareParser(sut.program_parser()))
for case in cases:
checker.check_invalid_syntax__abs_stx(self, case.value)
def test(self):
cases = [
Case.of(
'absolute_path',
PathStringAbsStx(
StringLiteralAbsStx.of_shlex_quoted(sys.executable)),
arguments=(),
expectation=ExpectationOnExeFile(
path_ddv=path_ddvs.absolute_file_name(sys.executable),
expected_symbol_references=[],
),
source_after_parse=asrt_source.is_at_end_of_line(1),
),
Case.of(
'without_option',
PathStringAbsStx.of_plain_str('file'),
arguments=[ArgumentOfRichStringAbsStx.of_str('arg2')],
expectation=ExpectationOnExeFile(
path_ddv=path_of_default_relativity('file'),
expected_symbol_references=[],
),
source_after_parse=has_remaining_part_of_first_line('arg2'),
),
Case.of(
'relative_file_name_with_space',
PathStringAbsStx(
StringLiteralAbsStx('the file', QuoteType.SOFT)),
arguments=(),
expectation=ExpectationOnExeFile(
path_ddv=path_of_default_relativity('the file'),
expected_symbol_references=[],
),
source_after_parse=asrt_source.is_at_end_of_line(1),
),
Case.of(
'relative_file_name_with_space_and_arguments',
PathStringAbsStx(
StringLiteralAbsStx('the file', QuoteType.SOFT)),
arguments=[
ArgumentOfRichStringAbsStx.of_str('an argument',
QuoteType.SOFT)
],
expectation=ExpectationOnExeFile(
path_ddv=path_of_default_relativity('the file'),
expected_symbol_references=[],
),
source_after_parse=has_remaining_part_of_first_line(
'"an argument"'),
),
Case.of(
'option_without_tail',
RelOptPathAbsStx(RelOptionType.REL_HDS_CASE, 'THE_FILE'),
arguments=(),
expectation=ExpectationOnExeFile(
path_ddv=path_of(RelOptionType.REL_HDS_CASE, 'THE_FILE'),
expected_symbol_references=[],
),
source_after_parse=asrt_source.is_at_end_of_line(1),
),
Case.of(
'option_with_tail',
RelOptPathAbsStx(RelOptionType.REL_CWD, 'FILE'),
arguments=[ArgumentOfRichStringAbsStx.of_str('tail')],
expectation=ExpectationOnExeFile(
path_ddv=path_of(RelOptionType.REL_CWD, 'FILE'),
expected_symbol_references=[],
),
source_after_parse=has_remaining_part_of_first_line('tail'),
),
]
for case in cases:
with self.subTest(name=case.name):
_parse_and_check(self, case)
def test(self):
# ARRANGE #
plain_string1 = 'plain_1'
plain_string2 = 'plain_2'
symbol_name_1 = 'symbol_name_1'
symbol_name_2 = 'symbol_name_2'
remaining_part_of_current_line_with_sym_ref = ''.join([
'before',
symbol_reference_syntax_for_name(symbol_name_2), 'after'
])
cases = [
Case.of_multi(
'plain strings', [
ArgumentOfRichStringAbsStx.of_str(plain_string1),
ArgumentOfRichStringAbsStx.of_str(plain_string2)
], ARRANGEMENT__NEUTRAL,
Expectation(
elements=[
list_sdvs.str_element(plain_string1),
list_sdvs.str_element(plain_string2)
],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of_multi(
'plain strings on several lines (separated by continuation token)',
[
ArgumentOfRichStringAbsStx.of_str(plain_string1),
ContinuationTokenFollowedByArgumentAbsStx(
ArgumentOfRichStringAbsStx.of_str(plain_string2)),
], ARRANGEMENT__NEUTRAL,
Expectation(
elements=[
list_sdvs.str_element(plain_string1),
list_sdvs.str_element(plain_string2)
],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of_multi(
'plain strings on several lines (separated by continuation token) / first line empty',
[
ContinuationTokenFollowedByArgumentAbsStx(
ArgumentOfRichStringAbsStx.of_str(plain_string1)),
ArgumentOfRichStringAbsStx.of_str(plain_string2),
], ARRANGEMENT__NEUTRAL,
Expectation(
elements=[
list_sdvs.str_element(plain_string1),
list_sdvs.str_element(plain_string2)
],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of_multi(
'symbol reference + plain string + until-end-of-line', [
ArgumentOfSymbolReferenceAbsStx(symbol_name_1),
ArgumentOfRichStringAbsStx.of_str(plain_string1),
ArgumentOfRichStringAbsStx.of_str_until_eol(
remaining_part_of_current_line_with_sym_ref),
],
Arrangement(
SymbolContext.symbol_table_of_contexts([
StringSymbolContext.of_arbitrary_value(symbol_name_1),
StringSymbolContext.of_arbitrary_value(symbol_name_2),
])),
Expectation(
elements=[
list_sdvs.symbol_element(
reference_to__on_direct_and_indirect(
symbol_name_1)),
list_sdvs.str_element(plain_string1),
list_sdvs.string_element(
string_sdvs.from_fragments([
string_sdvs.str_fragment('before'),
string_sdvs.symbol_fragment(
reference_to__on_direct_and_indirect(
symbol_name_2)),
string_sdvs.str_fragment('after'),
]))
],
validators=asrt.is_empty_sequence,
references=asrt.matches_sequence([
asrt_sym_ref.matches_reference_2(
symbol_name_1,
asrt_data_rest.is__w_str_rendering()),
asrt_sym_ref.matches_reference_2(
symbol_name_2,
asrt_data_rest.is__w_str_rendering()),
]),
)),
]
# ACT & ASSERT #
_test_cases_w_source_variants(self, cases)
def test_remaining_part_of_current_line_as_literal(self):
# ARRANGE #
symbol_name = 'symbol_name'
str_with_space_and_invalid_token_syntax = 'before and after space, ' + SOFT_QUOTE_CHAR + 'after quote'
cases = [
Case.of(
'string with one space after marker, and no space at EOL',
ArgumentOfRichStringAbsStx.of_str_until_eol(
str_with_space_and_invalid_token_syntax),
ARRANGEMENT__NEUTRAL,
Expectation(
elements=[
list_sdvs.str_element(
str_with_space_and_invalid_token_syntax)
],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of(
'with surrounding space',
ArgumentOfRichStringAbsStx.of_str_until_eol(
' ' + str_with_space_and_invalid_token_syntax + ' \t '),
ARRANGEMENT__NEUTRAL,
Expectation(
elements=[
list_sdvs.str_element(
str_with_space_and_invalid_token_syntax)
],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of(
'with symbol reference',
ArgumentOfRichStringAbsStx.of_str_until_eol(''.join([
'before',
symbol_reference_syntax_for_name(symbol_name), 'after'
])),
Arrangement(
StringSymbolContext.of_arbitrary_value(
symbol_name).symbol_table),
Expectation(
elements=[
list_sdvs.string_element(
string_sdvs.from_fragments([
string_sdvs.str_fragment('before'),
string_sdvs.symbol_fragment(
reference_to__on_direct_and_indirect(
symbol_name)),
string_sdvs.str_fragment('after'),
]))
],
validators=asrt.is_empty_sequence,
references=asrt.matches_sequence([
asrt_sym_ref.matches_reference_2(
symbol_name, asrt_data_rest.is__w_str_rendering())
]),
)),
]
# ACT & ASSERT #
_test_cases_w_source_variants(self, cases)
def test_list_of_arguments_and_symbol_references(self):
arg_wo_space = 'arg_wo_space'
arg_w_space = 'an arg w space'
string_symbol_1 = StringConstantSymbolContext(
'STRING_SYMBOL_1',
'value of string symbol 1',
default_restrictions=asrt_data_rest.is__w_str_rendering(),
)
string_symbol_2 = StringConstantSymbolContext(
'STRING_SYMBOL_2',
'value of string symbol 2',
default_restrictions=asrt_data_rest.is__w_str_rendering(),
)
arguments_cases = [
ArgumentsCase(
'one / wo symbol references',
arguments=[
ArgumentOfRichStringAbsStx.of_str(arg_w_space,
QuoteType.SOFT)
],
expected_arguments=[arg_w_space],
symbols=(),
),
ArgumentsCase(
'two / wo symbol references',
arguments=[
ArgumentOfRichStringAbsStx.of_str(arg_wo_space),
ArgumentOfRichStringAbsStx.of_str(arg_w_space,
QuoteType.HARD)
],
expected_arguments=[arg_wo_space, arg_w_space],
symbols=(),
),
ArgumentsCase(
'three / w symbol references',
arguments=[
ArgumentOfSymbolReferenceAbsStx(string_symbol_1.name),
ArgumentOfRichStringAbsStx.of_str(arg_w_space,
QuoteType.HARD),
ArgumentOfSymbolReferenceAbsStx(string_symbol_2.name)
],
expected_arguments=[
string_symbol_1.str_value, arg_w_space,
string_symbol_2.str_value
],
symbols=[string_symbol_1, string_symbol_2],
),
]
# ARRANGE #
for pgm_and_args_case in pgm_and_args_cases.cases__w_argument_list__excluding_program_reference(
):
for arguments_case in arguments_cases:
pgm_w_args = PgmAndArgsWArgumentsAbsStx(
pgm_and_args_case.pgm_and_args, arguments_case.arguments)
expected_arguments = asrt.equals(
arguments_case.expected_arguments)
symbols = list(pgm_and_args_case.symbols) + list(
arguments_case.symbols)
expectation = MultiSourceExpectation(
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
primitive=lambda env: (asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=pgm_and_args_case.expected_command_driver(
env),
arguments=expected_arguments,
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)))
with self.subTest(command=pgm_and_args_case.name,
arguments=arguments_case.name):
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
pgm_w_args,
pgm_and_args_case.mk_arrangement(
SymbolContext.symbol_table_of_contexts(symbols)),
expectation,
)
def test_transformation_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
transformer__in_referenced_program = StringTransformerPrimitiveSymbolContext(
'TRANSFORMER_IN_REFERENCED_PROGRAM',
string_transformers.delete_everything())
referenced_program__system_program = 'the-system-program'
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(referenced_program__system_program),
transformations=[transformer__in_referenced_program.reference_sdv])
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
transformer__in_source = StringTransformerPrimitiveSymbolContext(
'TRANSFORMER_IN_SOURCE', string_transformers.to_uppercase())
symbols__symbol_table = [
referenced_program, transformer__in_referenced_program,
transformer__in_source
]
symbols__expected_references = [
referenced_program, transformer__in_source
]
arguments_cases = [
NameAndValue(
'no arguments',
[],
),
NameAndValue(
'single argument',
['arg1'],
)
]
for arguments_case in arguments_cases:
with self.subTest(arguments=arguments_case.name):
program_w_transformer = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, [
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments_case.value
]),
transformation=transformer__in_source.abstract_syntax)
expected_primitive = asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=asrt_command.
matches_system_program_command_driver(
asrt.equals(referenced_program__system_program)),
arguments=asrt.equals(arguments_case.value),
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt.matches_sequence([
asrt.is_(transformer__in_referenced_program.primitive),
asrt.is_(transformer__in_source.primitive),
]),
)
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
program_w_transformer,
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__symbol_table), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
primitive=expected_primitive,
))
def of_execute_python_src_string(py_src: str) -> PgmAndArgsAbsStx:
return ProgramOfPythonInterpreterAbsStx([
ArgumentOfRichStringAbsStx.of_str(python_program_execution.PY_ARG_FOR_EXECUTING_SOURCE_ON_COMMAND_LINE),
ArgumentOfRichStringAbsStx.of_str_until_eol(py_src),
])
def runTest(self):
# ARRANGE #
program_name_string_symbol = StringConstantSymbolContext(
'PROGRAM_NAME_STRING_SYMBOL_NAME', 'the program name')
argument_string_symbol = StringConstantSymbolContext(
'ARGUMENT_STRING_SYMBOL_NAME', 'the argument')
symbols = SymbolContext.symbol_table_of_contexts([
program_name_string_symbol,
argument_string_symbol,
])
file_name = 'a-file.txt'
file_arg_relativity = relativity_options.conf_rel_any(
RelOptionType.REL_HDS_CASE)
path = path_ddvs.of_rel_option(file_arg_relativity.relativity_option,
path_ddvs.constant_path_part(file_name))
argument_cases = [
ArgumentsCase(
'no arguments',
source_elements=[],
expected_resolved_values=lambda tcds: [],
expected_symbol_references=[],
),
ArgumentsCase(
'single constant argument',
source_elements=[
ArgumentOfRichStringAbsStx.of_str('argument')
],
expected_resolved_values=lambda tcds: ['argument'],
expected_symbol_references=[],
),
ArgumentsCase(
'symbol reference and constant argument',
source_elements=[
ArgumentOfSymbolReferenceAbsStx(
argument_string_symbol.name),
ArgumentOfRichStringAbsStx.of_str('argument')
],
expected_resolved_values=lambda tcds:
[argument_string_symbol.str_value, 'argument'],
expected_symbol_references=[
argument_string_symbol.reference_assertion__w_str_rendering
]),
ArgumentsCase(
'existing file argument',
source_elements=[
ArgumentOfExistingPathAbsStx(
file_arg_relativity.path_abs_stx_of_name(file_name),
NonSymLinkFileType.REGULAR)
],
expected_resolved_values=lambda tcds:
[str(path.value_of_any_dependency(tcds))],
expected_symbol_references=[],
tcds_contents=file_arg_relativity.
populator_for_relativity_option_root(
DirContents([File.empty(file_name)]))),
]
program_cases = [
ProgramNameCase('string constant',
source_element=RawSystemCommandLineAbsStx.of_str(
'the_program'),
expected_resolved_value='the_program',
expected_symbol_references=[]),
ProgramNameCase(
'symbol reference',
source_element=RawSystemCommandLineAbsStx(
StringSymbolAbsStx(program_name_string_symbol.name)),
expected_resolved_value=program_name_string_symbol.str_value,
expected_symbol_references=[
program_name_string_symbol.
reference_assertion__string__w_all_indirect_refs_are_strings
]),
]
for argument_case in argument_cases:
for program_case in program_cases:
# ACT & ASSERT #
self._check(program_case, argument_case, symbols)
def test_stdin_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
str_src_contents__of_argument = 'the_str_src_contents__of_argument'
str_src_contents__of_referenced_pgm = 'the_str_src_contents__of_program'
stdin_argument_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
str_src_contents__of_argument)
stdin_sdv__of_referenced = str_src_sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(str_src_contents__of_referenced_pgm))
referenced_program__system_program = 'the-system-program'
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(referenced_program__system_program),
stdin=[stdin_sdv__of_referenced],
)
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
symbols__symbol_table = [referenced_program]
symbols__expected_references = [referenced_program]
arguments_cases = [
NameAndValue(
'no arguments',
[],
),
NameAndValue(
'single argument',
['arg1'],
)
]
for arguments_case in arguments_cases:
with self.subTest(arguments=arguments_case.name):
program_w_stdin = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, [
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments_case.value
]),
stdin=stdin_argument_syntax,
)
expected_primitive = asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=asrt_command.
matches_system_program_command_driver(
asrt.equals(referenced_program__system_program)),
arguments=asrt.equals(arguments_case.value),
),
stdin=asrt.matches_sequence([
asrt_str_src.matches__str(
asrt.equals(str_src_contents__of_referenced_pgm)),
asrt_str_src.matches__str(
asrt.equals(str_src_contents__of_argument)),
]),
transformer=asrt_pgm_val.is_no_transformation(),
)
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
program_w_stdin,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__symbol_table), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
primitive=expected_primitive,
))
def test_shell_program_via_symbol_reference(self):
shell_command_line_of_referenced_program = 'initial shell command line'
arguments_of_referenced_program = ['arg1', 'arg 2']
referenced_shell_program_sdv = program_sdvs.shell_program(
string_sdvs.str_constant(shell_command_line_of_referenced_program),
ArgumentsSdv.new_without_validation(
list_sdvs.from_str_constants(arguments_of_referenced_program)),
)
referenced_program_symbol = ProgramSymbolContext.of_sdv(
'SHELL_PROGRAM_REFERENCE',
referenced_shell_program_sdv,
)
string_argument_symbol = StringConstantSymbolContext(
'STRING_ARGUMENT_SYMBOL',
'string argument',
)
list_argument_symbol = ListConstantSymbolContext(
'LIST_ARGUMENT_SYMBOL', ['list_arg_value_1', 'list arg value 2'])
str_w_list_template = 'before{}after'
str_w_list_ref = str_w_list_template.format(
list_argument_symbol.name__sym_ref_syntax)
expected_argument_strings = (
arguments_of_referenced_program +
[string_argument_symbol.str_value] +
list_argument_symbol.constant_list + [
str_w_list_template.format(' '.join(
list_argument_symbol.constant_list))
])
symbols = [
referenced_program_symbol, string_argument_symbol,
list_argument_symbol
]
syntax = ProgramOfSymbolReferenceAbsStx(
referenced_program_symbol.name, [
ArgumentOfSymbolReferenceAbsStx(string_argument_symbol.name),
ArgumentOfSymbolReferenceAbsStx(list_argument_symbol.name),
ArgumentOfRichStringAbsStx.of_str(str_w_list_ref),
])
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
command=asrt_command.equals_shell_command(
command_line=shell_command_line_of_referenced_program,
arguments=expected_argument_strings,
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
expectation = MultiSourceExpectation(
symbol_references=asrt.matches_sequence([
referenced_program_symbol.reference_assertion,
string_argument_symbol.reference_assertion__w_str_rendering,
list_argument_symbol.reference_assertion__w_str_rendering,
list_argument_symbol.reference_assertion__w_str_rendering,
]),
primitive=expected_program,
)
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
syntax,
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbols), ),
expectation,
)
