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 test_not_equals(self):
expected_string = 'expected value'
cases = [
NEA(
'differs__resolved_value',
string_sdvs.str_constant(expected_string),
string_sdvs.str_constant('actual value'),
),
NEA(
'differs__number_of_references',
string_sdvs.str_constant(expected_string),
sdv_with_references([
SymbolReference(
'symbol_name',
ReferenceRestrictionsOnDirectAndIndirect(
ArbitraryValueWStrRenderingRestriction.of_any()))
]),
),
NEA(
'different_number_of_references',
StringSdvTestImpl(expected_string, [
SymbolReference(
'expected_symbol_name',
ReferenceRestrictionsOnDirectAndIndirect(
ArbitraryValueWStrRenderingRestriction.of_any()))
]),
StringSdvTestImpl(expected_string, [
SymbolReference(
'actual_symbol_name',
ReferenceRestrictionsOnDirectAndIndirect(
ArbitraryValueWStrRenderingRestriction.of_any()))
]),
),
NEA(
'different_number_of_fragments',
StringSdvTestImpl(expected_string, [],
(string_sdvs.str_fragment('value'), )),
StringSdvTestImpl(expected_string, [], (())),
),
NEA(
'different_fragments',
StringSdvTestImpl(expected_string, [],
(string_sdvs.str_fragment('value 1'), )),
StringSdvTestImpl(expected_string, [],
(string_sdvs.str_fragment('value 2'), )),
),
]
for case in cases:
with self.subTest(case.name):
assertion = sut.equals_string_sdv(case.expected)
# ACT & ASSERT #
assert_that_assertion_fails(assertion, case.actual)
def for_system_program__from_pgm_and_args(
pgm_and_args: ProgramAndArguments) -> CommandSdv:
program = string_sdvs.str_constant(pgm_and_args.program)
arguments = list_sdvs.from_str_constants(pgm_and_args.arguments)
additional_arguments = ArgumentsSdv.new_without_validation(arguments)
return for_system_program(program).new_with_additional_arguments(
additional_arguments)
def test_equals(self):
test_cases = [
(
'Plain string',
string_sdvs.str_constant('string value'),
empty_symbol_table(),
),
(
'String with reference',
sdv_with_references([
SymbolReference(
'symbol_name',
ReferenceRestrictionsOnDirectAndIndirect(
ArbitraryValueWStrRenderingRestriction.of_any()))
]),
empty_symbol_table(),
),
]
for test_case_name, string_value, symbol_table in test_cases:
assert isinstance(string_value, StringSdv), 'Type info for IDE'
with self.subTest(msg='{}::with checked references::{}'.format(
sut.equals_string_sdv.__name__, test_case_name)):
assertion = sut.equals_string_sdv(string_value)
assertion.apply_with_message(self, string_value,
test_case_name)
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 _source_interpreter_with_system_command(
cmd_and_args: List[str]) -> NameAndValue[Actor]:
command_sdv = command_sdvs.for_system_program(
string_sdvs.str_constant(cmd_and_args[0]),
ArgumentsSdv(list_sdvs.from_str_constants(cmd_and_args[1:])),
)
return NameAndValue(actors.SOURCE_INTERPRETER_ACTOR.singular_name,
actor.actor(command_sdv))
def of_primitive_constant(
contents: str,
definition_source: Optional[
SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION,
) -> 'StringSourceSymbolValueContext':
return StringSourceSymbolValueContext.of_sdv(
sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(contents)),
definition_source,
)
def all_strings() -> Tuple[BuiltinSymbol, ...]:
return (
BuiltinSymbol(
OS_LINE_SEP,
ValueType.STRING,
string_sdvs.str_constant(os.linesep),
CustomSymbolDocumentation(
"The {plain_string} that separates text lines on the {current_os} ({NL}, {WIN_LINE_SEP}, e.g.)."
.format(
NL=misc_texts.NEW_LINE_STRING_CONSTANT,
WIN_LINE_SEP=formatting.string_constant('\\r\\n'),
current_os=misc_texts.CURRENT_OS,
plain_string=misc_texts.PLAIN_STRING,
),
SectionContents.empty(),
),
),
BuiltinSymbol(
NEW_LINE,
ValueType.STRING,
string_sdvs.str_constant('\n'),
CustomSymbolDocumentation(
"The new-line character ({NL}), the line separator of {string:s} handled by {program_name}"
.format(
NL=misc_texts.NEW_LINE_STRING_CONSTANT,
string=types.STRING_TYPE_INFO.name,
program_name=program_info.PROGRAM_NAME.capitalize(),
),
_TP.section_contents(_NEW_LINE_DESCRIPTION),
),
),
BuiltinSymbol(
TAB,
ValueType.STRING,
string_sdvs.str_constant('\t'),
CustomSymbolDocumentation(
'The tab character.',
SectionContents.empty(),
),
),
)
def test_sdv_SHOULD_be_given_as_argument_to_sdv_assertion(self):
# ARRANGE #
actual_sdv = string_sdvs.str_constant('s')
builtin_symbol = StringSymbolValueContext.of_sdv(
actual_sdv, definition_source=None)
assertion_that_is_expected_to_succeed = asrt.is_(actual_sdv)
assertion_to_check = sut.matches_container(
asrt.anything_goes(),
assertion_that_is_expected_to_succeed,
definition_source=asrt.anything_goes())
# ACT & ASSERT #
assertion_to_check.apply_without_message(self,
builtin_symbol.container)
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 test_arbitrary_failure(self):
# ARRANGE #
actual_sdv = string_sdvs.str_constant('s')
source_line = single_line_sequence(1, 'source line')
actual_container = StringSymbolValueContext(
actual_sdv,
source_location.source_info_for_line_sequence(
source_line)).container
assertion_that_is_expected_to_fail = asrt.not_(
equals_line_sequence(source_line))
assertion_to_check = sut.matches_container(
value_type=asrt.anything_goes(),
sdv=asrt.anything_goes(),
definition_source=assertion_that_is_expected_to_fail)
assert_that_assertion_fails(assertion_to_check, actual_container)
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_source_line_SHOULD_be_given_as_argument_to_source_line_assertion(
self):
# ARRANGE #
actual_sdv = string_sdvs.str_constant('s')
source_line = single_line_sequence(1, 'source line')
actual_container = StringSymbolValueContext(
actual_sdv,
source_location.source_info_for_line_sequence(
source_line)).container
assertion_that_is_expected_to_succeed = equals_line_sequence(
source_line)
assertion_to_check = sut.matches_container(
value_type=asrt.anything_goes(),
sdv=asrt.anything_goes(),
definition_source=assertion_that_is_expected_to_succeed)
# ACT & ASSERT #
assertion_to_check.apply_without_message(self, actual_container)
def __init__(
self,
fm_validation_case: fm_validation_cases.ValidationCase,
symbol_name: str,
):
self._expectation = fm_validation_case.expectation
self._symbol_context = FilesConditionSymbolContext.of_sdv(
symbol_name,
files_conditions.new_constant([
(string_sdvs.str_constant('a_valid_file_name'),
fm_sdvs.new_reference(fm_validation_case.symbol_context.name))
]),
)
self._symbol_table = SymbolContext.symbol_table_of_contexts([
self._symbol_context,
fm_validation_case.symbol_context,
])
def test_reference_SHOULD_be_equal_to_referenced_value(self):
# ARRANGE #
file_name = 'the-file-name'
referenced_sdv = files_conditions.new_constant([
(string_sdvs.str_constant(file_name), None)
])
expected = asrt_primitive.files_matches(
{PurePosixPath(file_name): asrt.is_none})
symbol = FilesConditionSymbolContext.of_sdv('fc_symbol',
referenced_sdv)
source = args.SymbolReferenceWReferenceSyntax(symbol.name)
# ACT & ASSERT #
CHECKER.check__w_source_variants(
self, source.as_arguments, None,
arrangement_wo_tcds(symbol.symbol_table),
Expectation(
ParseExpectation(
symbol_references=symbol.references_assertion),
ExecutionExpectation(), prim_asrt__constant(expected)))
def test_validation_SHOULD_fail_WHEN_resolved_value_is_not_an_integer(
self):
the_instruction_environment = instruction_environment.fake_pre_sds_environment(
)
test_cases = [
'a',
'1+x',
'a b',
'10 a',
'10a',
'1.5',
]
for custom_validator in [None, do_return(None)]:
for resolved_value in test_cases:
with self.subTest(
custom_validator_is_none=str(custom_validator is None),
resolved_value=resolved_value):
# ARRANGE #
sdv_to_check = sut.IntegerSdv(
string_sdvs.str_constant(resolved_value),
custom_validator)
with self.subTest(tested_obect='sdv'):
# ACT & ASSERT #
with self.assertRaises(SvhValidationException) as cm:
sdv_to_check.validate_pre_sds(
the_instruction_environment.
path_resolving_environment)
asrt_text_doc.is_any_text().apply_without_message(
self, cm.exception.err_msg)
with self.subTest(tested_obect='value'):
# ACT & ASSERT #
value_to_check = sdv_to_check.resolve(
the_instruction_environment.symbols)
actual = value_to_check.validator(
).validate_pre_sds_if_applicable(
the_instruction_environment.hds)
asrt_text_doc.is_any_text().apply_without_message(
self, actual)
def test_validation_SHOULD_succeed_WHEN_value_is_an_integer_and_custom_validator_succeeds(
self):
the_instruction_environment = instruction_environment.fake_pre_sds_environment(
)
resolved_value = 16
resolved_string_value_cases = [
'16',
'8 + 8',
'2 * 2 * 2 * 2',
]
custom_validator_cases = [
None,
CustomValidator(
value_that_makes_the_validation_succeed=resolved_value,
error_message=validation.new_single_string_text_for_test(
'error message from custom validator'))
]
for value_string in resolved_string_value_cases:
for custom_validator in custom_validator_cases:
sdv_to_check = sut.IntegerSdv(
string_sdvs.str_constant(str(value_string)),
custom_validator)
with self.subTest(
custom_validator_is_none=str(custom_validator is None),
value_string=value_string):
with self.subTest(tested_obect='sdv'):
sdv_to_check.validate_pre_sds(
the_instruction_environment.
path_resolving_environment)
with self.subTest(tested_obect='value'):
value_to_check = sdv_to_check.resolve(
the_instruction_environment.symbols)
value_to_check.validator(
).validate_pre_sds_if_applicable(
the_instruction_environment.hds)
value_to_check.validator(
).validate_post_sds_if_applicable(fake_tcds())
def test_validation_SHOULD_fail_WHEN_custom_validator_fails(self):
the_instruction_environment = instruction_environment.fake_pre_sds_environment(
)
resolved_value = 1
# ARRANGE #
error_message_from_custom_validator = 'error message'
sdv_to_check = sut.IntegerSdv(
string_sdvs.str_constant(str(resolved_value)),
CustomValidator(
value_that_makes_the_validation_succeed=resolved_value + 1,
error_message=validation.new_single_string_text_for_test(
error_message_from_custom_validator)))
with self.subTest(tested_obect='sdv'):
# ACT & ASSERT #
with self.assertRaises(SvhValidationException) as cm:
sdv_to_check.validate_pre_sds(
the_instruction_environment.path_resolving_environment)
err_msg_expectation = asrt_text_doc.is_string_for_test_that_equals(
error_message_from_custom_validator)
err_msg_expectation.apply_without_message(self,
cm.exception.err_msg)
with self.subTest(tested_obect='value'):
# ACT & ASSERT #
value_to_check = sdv_to_check.resolve(
the_instruction_environment.symbols)
actual = value_to_check.validator().validate_pre_sds_if_applicable(
the_instruction_environment.hds)
err_msg_expectation = asrt_text_doc.is_string_for_test_that_equals(
error_message_from_custom_validator)
err_msg_expectation.apply_without_message(self, actual)
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 str_element(s: str) -> ElementSdv:
return string_element(_string_sdvs.str_constant(s))
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_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,
)
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 _arbitrary_sdv__string() -> Tuple[ValueType, DataTypeSdv]:
return ValueType.STRING, string_sdvs.str_constant('a string (from <string value restriction>)')
def all_command_driver_types() -> Sequence[CommandDriverSdvCase]:
# ARRANGE #
system_program_name = 'system-program'
executable_program_file_name = 'executable-program-file'
executable_file_relativity = relativity_options.conf_rel_any(
RelOptionType.REL_HDS_ACT)
executable_file_ddv = path_ddvs.of_rel_option(
executable_file_relativity.relativity_option,
path_ddvs.constant_path_part(executable_program_file_name))
shell_initial_command = 'shell initial command'
def mk_arrangement__executable_file(symbols: SymbolTable) -> Arrangement:
return arrangement_w_tcds(
symbols=symbols,
tcds_contents=executable_file_relativity.
populator_for_relativity_option_root(
fs.DirContents(
[fs.executable_file(executable_program_file_name)])))
def expected_command_driver__system_program(
env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]:
return asrt_command.matches_system_program_command_driver(
asrt.equals(system_program_name))
def expected_command_driver__executable_file(
env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]:
return asrt_command.matches_executable_file_command_driver(
asrt.equals(
executable_file_ddv.value_of_any_dependency__d(
env.tcds).primitive), )
def expected_command_driver__shell_cmd_line(
env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]:
return asrt_command.matches_shell_command_driver(
asrt.equals(shell_initial_command))
return [
CommandDriverSdvCase(
'system program',
command_driver=driver_sdvs.CommandDriverSdvForSystemProgram(
string_sdvs.str_constant(system_program_name)),
expected_command_driver=expected_command_driver__system_program,
mk_arrangement=lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl
),
),
CommandDriverSdvCase(
'executable program file',
command_driver=driver_sdvs.CommandDriverSdvForExecutableFile(
path_sdvs.constant(executable_file_ddv)),
expected_command_driver=expected_command_driver__executable_file,
mk_arrangement=mk_arrangement__executable_file,
),
CommandDriverSdvCase(
'shell command line',
command_driver=driver_sdvs.CommandDriverSdvForShell(
string_sdvs.str_constant(shell_initial_command)),
expected_command_driver=expected_command_driver__shell_cmd_line,
mk_arrangement=lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl
),
),
]
def test_not_equals__string(self):
# ARRANGE #
expected = str_constant('expected string')
actual = str_constant('actual string')
# ACT & ASSERT #
assert_that_assertion_fails(sut.equals_data_type_sdv(expected), actual)
def test_not_equals__different_symbol_types(self):
# ARRANGE #
expected = path_sdvs.constant(path_test_impl('file-name'))
actual = str_constant('string value')
# ACT & ASSERT #
assert_that_assertion_fails(sut.equals_data_type_sdv(expected), actual)
def test_equals__string(self):
# ARRANGE #
value = str_constant('string')
# ACT & ASSERT #
sut.equals_data_type_sdv(value).apply_without_message(self, value)
