def program_sdv_w_stdin__wo_sym_refs(contents_of_stdin: str) -> ProgramSdv:
return program_sdvs.system_program(
string_sdvs.str_constant('the-system-program'),
stdin=[str_src_sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(contents_of_stdin)
)],
)
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 run_test(self):
relativity_conf = relativity_options.conf_rel_any(
self._missing_file_relativity)
referenced_program_arguments = [
'valid arg 1 of referenced', 'valid arg 2 of referenced'
]
referenced_system_program_sdv = program_sdvs.system_program(
string_sdvs.str_constant('valid-system-program'),
ArgumentsSdv.new_without_validation(
list_sdvs.from_str_constants(referenced_program_arguments)))
valid_program_symbol = ProgramSymbolContext.of_sdv(
'VALID_PROGRAM', referenced_system_program_sdv)
invalid_argument_syntax = ArgumentOfExistingPathAbsStx(
relativity_conf.path_abs_stx_of_name('non-existing-file'))
reference_and_additional_invalid_argument = self.source_to_parse(
valid_program_symbol.name,
[invalid_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=FAILING_VALIDATION_ASSERTION_FOR_PARTITION[
relativity_conf.directory_structure_partition], )),
)
def program_reference__w_argument_list() -> PgmAndArgsCase:
system_program = 'the-system-program'
system_program_sdv = program_sdvs.system_program(string_sdvs.str_constant(system_program))
system_program_symbol = ProgramSymbolContext.of_sdv('SYSTEM_PROGRAM_SYMBOL', system_program_sdv)
return PgmAndArgsCase.wo_tcds(
'reference to program w argument list',
pgm_and_args=ProgramOfSymbolReferenceAbsStx(system_program_symbol.name),
symbols=[system_program_symbol],
expected_command_driver=prim_asrt__constant(
asrt_command.matches_system_program_command_driver(
asrt.equals(system_program)
)),
)
def __init__(
self,
symbol_name: str,
string_transformer_case: str_trans_validation_cases.ValidationCase,
):
self._string_transformer_case = string_transformer_case
additional_components = AccumulatedComponents.of_transformation(
StringTransformerSdvReference(
string_transformer_case.symbol_context.name))
program_w_transformer = program_sdvs.system_program(
string_sdvs.str_constant('system-program')).new_accumulated(
additional_components)
self._program_symbol_context = ProgramSymbolContext.of_sdv(
symbol_name, program_w_transformer)
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 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_stdin_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
stdin_contents = 'str_src_contents'
valid_stdin_sdv = sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(stdin_contents))
valid_stdin_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
stdin_contents)
referenced_program__system_program = 'the-system-program'
for validation_case in validation_cases.failing_validation_cases():
invalid_stdin_location_cases = [
ValidationCaseWAccumulation(
'in referenced symbol',
sdv_of_referenced_program=validation_case.value.
symbol_context.sdv,
syntax_accumulated=valid_stdin_syntax,
symbols=[],
),
ValidationCaseWAccumulation(
'as source argument',
sdv_of_referenced_program=valid_stdin_sdv,
syntax_accumulated=validation_case.value.syntax,
symbols=[validation_case.value.symbol_context],
),
]
for invalid_stdin_location_case in invalid_stdin_location_cases:
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(
referenced_program__system_program),
stdin=[
invalid_stdin_location_case.sdv_of_referenced_program
])
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
program_w_stdin = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, ),
stdin=invalid_stdin_location_case.syntax_of_accumulated,
)
symbols__all = [
validation_case.value.symbol_context, referenced_program
]
symbols__expected_references = [
referenced_program
] + invalid_stdin_location_case.symbols
# 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__all), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
execution=ExecutionExpectation(
validation=validation_case.value.assertion, ),
primitive=asrt.anything_goes(),
),
sub_test_identifiers={
'validation': validation_case.name,
'invalid_stdin_location':
invalid_stdin_location_case.name,
})
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 test_transformation_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
valid_transformer = StringTransformerSymbolContext.of_arbitrary_value(
'VALID_TRANSFORMER', )
referenced_program__system_program = 'the-system-program'
for validation_case in validation_cases.failing_validation_cases(
'INVALID_TRANSFORMER'):
invalid_transformer_location_cases = [
ValidationCaseWAccumulation(
'in referenced program',
of_referenced_program=validation_case.value.symbol_context,
accumulated=valid_transformer,
),
ValidationCaseWAccumulation(
'in referenced program',
of_referenced_program=valid_transformer,
accumulated=validation_case.value.symbol_context,
),
]
for invalid_transformer_location_case in invalid_transformer_location_cases:
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(
referenced_program__system_program),
transformations=[
invalid_transformer_location_case.
of_referenced_program.reference_sdv
])
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
program_w_transformer = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, ),
transformation=invalid_transformer_location_case.
accumulated.abstract_syntax,
)
symbols__all = [
referenced_program,
valid_transformer,
validation_case.value.symbol_context,
]
symbols__expected_references = [
referenced_program,
invalid_transformer_location_case.accumulated
]
with self.subTest(validation=validation_case.name,
invalid_transformer_location=
invalid_transformer_location_case.name):
# 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__all), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
execution=ExecutionExpectation(
validation=validation_case.value.expectation,
),
primitive=asrt.anything_goes(),
))
def run_test(self):
# ARRANGE #
arguments_of_referenced_sdv_symbol = ListConstantSymbolContext(
'ARGUMENT_OF_SDV_SYMBOL',
['argument of sdv 1', 'argument of sdv 2'],
)
referenced_system_program_name = 'the-referenced-system-program'
referenced_program_arguments = arguments_of_referenced_sdv_symbol.constant_list
referenced_system_program_sdv = program_sdvs.system_program(
string_sdvs.str_constant(referenced_system_program_name),
ArgumentsSdv.new_without_validation(
list_sdvs.from_elements([
list_sdvs.symbol_element(
SymbolReference(
arguments_of_referenced_sdv_symbol.name,
ValueTypeRestriction.of_single(ValueType.LIST)))
])))
program_symbol = ProgramSymbolContext.of_sdv(
'PROGRAM_SYMBOL', referenced_system_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'])
symbols = SymbolContext.symbol_table_of_contexts([
program_symbol, arguments_of_referenced_sdv_symbol,
string_argument_symbol, list_argument_symbol
])
cases = [
SymbolReferencesCase(
'just program reference symbol',
self.source_to_parse(program_symbol.name, ()),
references_expectation=asrt.matches_sequence([
references.is_reference_to_program(program_symbol.name),
]),
expected_additional_arguments=[],
),
SymbolReferencesCase(
'arguments that are references to string and list symbols',
self.source_to_parse(program_symbol.name, [
ArgumentOfSymbolReferenceAbsStx(
string_argument_symbol.name),
ArgumentOfSymbolReferenceAbsStx(list_argument_symbol.name)
]),
references_expectation=asrt.matches_sequence([
references.is_reference_to_program(program_symbol.name),
string_argument_symbol.
reference_assertion__w_str_rendering,
list_argument_symbol.reference_assertion__w_str_rendering,
]),
expected_additional_arguments=(
[string_argument_symbol.str_value] +
list_argument_symbol.constant_list),
),
]
for case in cases:
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
command=asrt_command.equals_system_program_command(
program=referenced_system_program_name,
arguments=referenced_program_arguments +
case.expected_additional_arguments,
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
expectation = MultiSourceExpectation(
symbol_references=case.references_expectation,
primitive=expected_program,
)
with self.put.subTest(case=case.name):
# 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,
case.source,
arrangement_wo_tcds(symbols=symbols, ),
expectation,
)
