def failing_validation_cases__multi_exe(
symbol_name: str = 'files_matcher_symbol'
) -> Sequence[NExArr[PrimAndExeExpectation, Arrangement]]:
return [
NExArr(
case.name,
PrimAndExeExpectation.of_exe(validation=case.value.expectation, ),
arrangement_wo_tcds(
symbols=case.value.symbol_context.symbol_table, ),
) for case in failing_validation_cases(symbol_name)
]
def test_file_matcher_SHOULD_be_parsed_as_full_expression(self):
# ARRANGE #
file_name = 'file-name'
fm_1 = FileMatcherSymbolContextOfPrimitiveConstant(
'file_matcher_1', False)
fm_2 = FileMatcherSymbolContextOfPrimitiveConstant(
'file_matcher_2', True)
symbols = [fm_1, fm_2]
arguments = args.FilesCondition([
args.FileCondition(
file_name, fm_args.disjunction([fm_1.argument, fm_2.argument]))
])
expected_result = fm_1.result_value or fm_2.result_value
# ACT & ASSERT #
CHECKER.check__w_source_variants(
self,
arguments=arguments.as_arguments,
input_=None,
arrangement=arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbols)),
expectation=Expectation(
ParseExpectation(symbol_references=SymbolContext.
references_assertion_of_contexts(symbols)),
primitive=prim_asrt__constant(
asrt_primitive.files_matches({
PurePosixPath(file_name):
asrt_primitive.is_matcher_that_gives(expected_result)
}))))
def test_string_symbol_reference(self):
for other_valid_file_spec_case in OTHER_VALID_FILE_SPECS:
for file_name_case in INVALID_FILE_NAMES:
file_name_symbol = StringSymbolContext.of_constant(
'FILE_NAME_SYMBOL',
file_name_case.value,
default_restrictions=asrt_rest.is__string__w_all_indirect_refs_are_strings(),
)
file_name_abs_stx = file_name_symbol.abstract_syntax
for file_spec_case in file_type_and_contents_variants(file_name_abs_stx):
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
LiteralFilesSourceAbsStx(other_valid_file_spec_case.value + [file_spec_case.value]),
models.empty(),
arrangement_wo_tcds(
symbols=file_name_symbol.symbol_table
),
MultiSourceExpectation(
symbol_references=file_name_symbol.references_assertion,
execution=ExecutionExpectation(
validation=ValidationAssertions.pre_sds_fails__w_any_msg()
)
),
sub_test_identifiers={
'file-name': file_name_case.name,
'type-and-contents': file_spec_case.name,
'other-valid-file-spec': other_valid_file_spec_case.name,
}
)
def test_one_file_wo_matcher_and_one_w_matcher(self):
# ARRANGE #
file_name_w_matcher = 'file-name-with-matcher'
file_name_wo_matcher = 'file-name-without-matcher'
fm_symbol = 'file_matcher'
arguments = args.FilesCondition([
args.FileCondition(file_name_wo_matcher),
args.FileCondition(
file_name_w_matcher,
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)),
])
# ACT & ASSERT #
CHECKER.check_multi__w_source_variants(
self, arguments.as_arguments,
asrt.matches_sequence([is_reference_to_file_matcher(fm_symbol)]),
None, [
NExArr(
'FileMatcher should give {}'.format(expected_result),
PrimAndExeExpectation.of_prim__const(
asrt_primitive.files_matches({
PurePosixPath(file_name_wo_matcher):
asrt.is_none,
PurePosixPath(file_name_w_matcher):
asrt_primitive.is_matcher_that_gives(
expected_result)
})),
arrangement_wo_tcds(
FileMatcherSymbolContext.of_primitive_constant(
fm_symbol, expected_result).symbol_table),
) for expected_result in [False, True]
])
def _check_case(self,
invalid_file_spec: FileSpecAbsStx,
contents_case: ContentsCase,
validation_case: NameAndValue[ValidationCaseWSymbolContextAndAssertion],
):
symbol_context = validation_case.value.symbol_context
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
LiteralFilesSourceAbsStx(contents_case.other_valid_file_spec.value + [invalid_file_spec]),
models.empty(),
arrangement_wo_tcds(
symbols=symbol_context.symbol_table
),
MultiSourceExpectation(
symbol_references=symbol_context.references_assertion,
execution=ExecutionExpectation(
validation=validation_case.value.assertion
)
),
sub_test_identifiers={
'validation': validation_case.name,
'other-valid-file-spec': contents_case.other_valid_file_spec.name,
'modification-type': contents_case.modification_type,
}
)
def test_transformer_component(self):
checker = integration_check.checker__w_arbitrary_file_relativities()
for validation_case in failing_validation_cases():
transformer_symbol = validation_case.value.symbol_context
program_syntax = program_abs_stx.FullProgramAbsStx(
program_abs_stx.ProgramOfSystemCommandLineAbsStx.of_str(
'a-system-command'),
transformation=transformer_symbol.abstract_syntax,
)
string_source_syntax = string_source_abs_stx.StringSourceOfProgramAbsStx(
ProcOutputFile.STDOUT,
program_syntax,
ignore_exit_code=False,
)
with self.subTest(validation_case.name):
checker.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
OptionallyOnNewLine(string_source_syntax),
arrangement_wo_tcds(
symbols=transformer_symbol.symbol_table),
MultiSourceExpectation(
symbol_references=transformer_symbol.
references_assertion,
execution=ExecutionExpectation(
validation=validation_case.value.expectation)))
def runTest(self):
# ARRANGE #
for result in [False, True]:
string_matcher = StringMatcherSymbolContextOfPrimitiveConstant(
'STRING_MATCHER',
result,
)
# ACT & ASSERT #
with self.subTest(string_matcher_result=result):
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
arguments=lm_args.Contents(
sm_args2.SymbolReferenceWReferenceSyntax(
string_matcher.name), ).as_arguments,
input_=models.ARBITRARY_MODEL,
arrangement=arrangement_wo_tcds(
symbols=string_matcher.symbol_table, ),
expectation=Expectation(
ParseExpectation(symbol_references=string_matcher.
references_assertion),
ExecutionExpectation(
main_result=asrt_matching_result.
matches_value__w_header(
asrt.equals(string_matcher.result_value),
header=TRACE_HEADER_EXPECTATION,
))),
)
def runTest(self):
string_matcher = StringMatcherSymbolContextOfPrimitiveConstant(
'STRING_MATCHER',
True,
)
after_bin_op = 'after bin op'
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
source=lm_args.Contents(
sm_args2.conjunction([
sm_args2.SymbolReference(string_matcher.name),
sm_args2.Custom(after_bin_op),
]), ).as_remaining_source,
input_=models.ARBITRARY_MODEL,
arrangement=arrangement_wo_tcds(
symbols=string_matcher.symbol_table, ),
expectation=Expectation(
ParseExpectation(
source=asrt_source.is_at_line(
current_line_number=1,
remaining_part_of_current_line=logic.AND_OPERATOR_NAME
+ ' ' + after_bin_op),
symbol_references=string_matcher.references_assertion),
ExecutionExpectation(
main_result=asrt_matching_result.matches_value__w_header(
asrt.equals(string_matcher.result_value),
header=TRACE_HEADER_EXPECTATION,
))),
)
def test_glob_pattern(self):
match_anything_glob_pattern_string_symbol = StringSymbolContext.of_constant(
'glob_pattern_symbol',
'*',
default_restrictions=glob_pattern.is_reference_restrictions__glob_pattern_string()
)
arguments = self.conf.arguments(
NameGlobPatternVariant(match_anything_glob_pattern_string_symbol.name__sym_ref_syntax)
)
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
arguments=
arguments.as_arguments,
input_=
ARBITRARY_MODEL,
arrangement=arrangement_wo_tcds(
symbols=match_anything_glob_pattern_string_symbol.symbol_table
),
expectation=Expectation(
ParseExpectation(
symbol_references=asrt.matches_sequence([
match_anything_glob_pattern_string_symbol.reference_assertion,
]),
),
ExecutionExpectation(
main_result=asrt_matching_result.matches_value__w_header(
asrt.equals(True),
asrt.equals(self.conf.node_name)
)
),
)
)
def runTest(self):
# ARRANGE #
for validation_case in validation_cases.failing_validation_cases():
for preserve_new_lines in [False, True]:
syntax = ReplaceRegexAbsStx.of_str(
'valid_regex',
'valid_replacement',
preserve_new_lines=preserve_new_lines,
lines_filter=validation_case.value.matcher_abs_stx,
)
line_matcher_symbol_context = validation_case.value.symbol_context
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants(
self,
syntax,
model_constructor.arbitrary(self),
arrangement_wo_tcds(
symbols=line_matcher_symbol_context.symbol_table),
MultiSourceExpectation(
symbol_references=line_matcher_symbol_context.
references_assertion,
execution=ExecutionExpectation(
validation=validation_case.value.expectation, )),
sub_test_identifiers={
'preserve_new_lines': preserve_new_lines,
'validation': validation_case.name,
})
def runTest(self):
# ARRANGE #
program_ref_case = pgm_and_args_cases.program_reference__w_argument_list()
def expected_program(env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=program_ref_case.expected_command_driver(env),
arguments=asrt.is_empty_sequence,
),
stdin=asrt_pgm_val.is_no_stdin(),
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,
OptionallyOnNewLine(WithinParensAbsStx(program_ref_case.pgm_and_args,
end_paren_on_separate_line=False)),
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(program_ref_case.symbols),
),
MultiSourceExpectation(
symbol_references=SymbolContext.references_assertion_of_contexts(program_ref_case.symbols),
primitive=expected_program,
)
)
def runTest(self):
# ARRANGE #
for case in validation_cases.failing_validation_cases():
line_matcher_symbol_context = case.value.symbol_context
line_matcher_arg = lm_args.SymbolReference(line_matcher_symbol_context.name)
arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg))
with self.subTest(case.name):
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
Arguments(arguments),
model_constructor.of_lines(self, []),
arrangement_wo_tcds(
symbols=line_matcher_symbol_context.symbol_table
),
Expectation(
ParseExpectation(
symbol_references=line_matcher_symbol_context.references_assertion
),
ExecutionExpectation(
validation=case.value.expectation,
)
)
)
def test_that_symbols_from_arrangement_exist_in_environment(self):
symbol = StringConstantSymbolContext('symbol_name', 'the symbol value')
symbol_table_of_arrangement = symbol.symbol_table
expected_symbol_table = symbol.symbol_table
expectation = asrt_sym.equals_symbol_table(expected_symbol_table)
sdv_that_checks_symbols = MatcherSdvThatAssertsThatSymbolsAreAsExpected(self, expectation)
cases = [
NameAndValue('arrangement without tcds',
arrangement_wo_tcds(
symbol_table_of_arrangement)
),
NameAndValue('arrangement with tcds',
arrangement_w_tcds(
symbols=symbol_table_of_arrangement)
),
]
for arrangement in cases:
with self.subTest(arrangement.name):
self._check___single_and_multi(
utils.single_line_arguments(),
ARBITRARY_MODEL,
_constant_line_matcher_type_parser_of_matcher_sdv(sdv_that_checks_symbols),
arrangement.value,
Expectation(),
)
def test_single_file_name_with_matcher(self):
# ARRANGE #
file_name = 'file-name'
fm_symbol = 'file_matcher'
cases = [
NameAndValue(
'single name entry',
args.FilesCondition([
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol))
]),
),
NameAndValue(
'two entries with same file name, 1st without and 2nd with FileMatcher',
args.FilesCondition([
args.FileCondition(file_name),
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)),
]),
),
NameAndValue(
'two entries with same file name, 1st with and 2nd without FileMatcher',
args.FilesCondition([
args.FileCondition(
file_name,
fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)),
args.FileCondition(file_name),
]),
),
]
# ACT & ASSERT #
for case in cases:
with self.subTest(case.name):
CHECKER.check_multi__w_source_variants(
self, case.value.as_arguments,
asrt.matches_sequence(
[is_reference_to_file_matcher(fm_symbol)]), None,
[
NExArr(
'FileMatcher should give {}'.format(
expected_result),
PrimAndExeExpectation.of_prim__const(
asrt_primitive.files_matches({
PurePosixPath(file_name):
asrt_primitive.is_matcher_that_gives(
expected_result)
})),
arrangement_wo_tcds(
FileMatcherSymbolContext.of_primitive_constant(
fm_symbol, expected_result).symbol_table),
) for expected_result in [False, True]
])
def check_with_source_variants(put: unittest.TestCase,
arguments: Arguments,
model_constructor: ModelConstructor,
arrangement: Optional[SymbolTable] = None,
expectation: Expectation = Expectation()):
CHECKER.check__w_source_variants(
put,
arguments,
model_constructor,
arrangement_wo_tcds(arrangement),
expectation,
)
def check(put: unittest.TestCase,
source: ParseSource,
model_constructor: ModelConstructor,
arrangement: Optional[SymbolTable] = None,
expectation: Expectation = Expectation()):
CHECKER.check(
put,
source,
model_constructor,
arrangement_wo_tcds(arrangement),
expectation,
)
def runTest(self):
cases = [
NameAndValue(
'just space',
' ',
),
NameAndValue(
'just space, w new-line',
' \n ',
),
NameAndValue(
'just a separator',
'{SEPARATOR}',
),
NameAndValue(
'just two separators',
'{SEPARATOR}{SEPARATOR}',
),
NameAndValue(
'too many separators 1',
'{SEPARATOR}1{SEPARATOR}',
),
NameAndValue(
'too many separators 2',
'1{SEPARATOR}{SEPARATOR}',
),
NameAndValue(
'too many separators 3',
'1{SEPARATOR}2{SEPARATOR}',
),
]
for case in cases:
with self.subTest(case.name, expr=case.value):
range_expr_symbol = StringSymbolContext.of_constant(
'RANGE_SYMBOL',
case.value,
default_restrictions=
IS_RANGE_EXPR_STR_REFERENCE_RESTRICTIONS,
)
arguments = args.filter_line_nums(
range_args.CustomRange(
range_expr_symbol.name__sym_ref_syntax))
integration_check.CHECKER__PARSE_SIMPLE.check(
self, arguments.as_remaining_source,
model_constructor.arbitrary(self),
arrangement_wo_tcds(
symbols=range_expr_symbol.symbol_table, ),
Expectation(
ParseExpectation(symbol_references=range_expr_symbol.
references_assertion, ),
ExecutionExpectation(validation=ValidationAssertions.
pre_sds_fails__w_any_msg(), ),
))
def _check_cases(
self, cases: Sequence[NArrEx[ArgumentElementsRenderer,
Assertion[IntIntervalWInversion]]]):
for case in cases:
with self.subTest(case.name, arguments=case.arrangement.as_str):
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
args.LineNum2(case.arrangement).as_remaining_source,
models.ARBITRARY_MODEL,
arrangement_wo_tcds(),
Expectation(primitive=prim_asrt__constant(
IntervalOfMatcherAssertion(case.expectation, ))),
)
def wo_tcds(name: str,
pgm_and_args: PgmAndArgsAbsStx,
expected_command_driver: Callable[[AssertionResolvingEnvironment], Assertion[CommandDriver]],
symbols: Sequence[SymbolContext] = (),
) -> 'PgmAndArgsCase':
return PgmAndArgsCase(
name,
pgm_and_args,
expected_command_driver,
symbols,
tcds_populators.empty(),
lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl)
)
def test_shell_program(self):
argument_string_template = 'first {string_symbol} between {list_symbol} after'
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 = [string_argument_symbol, list_argument_symbol]
command_line_syntax_str = argument_string_template.format(
string_symbol=string_argument_symbol.name__sym_ref_syntax,
list_symbol=list_argument_symbol.name__sym_ref_syntax,
)
command_line_str = argument_string_template.format(
string_symbol=string_argument_symbol.str_value,
list_symbol=' '.join(list_argument_symbol.constant_list),
)
syntax = ProgramOfShellCommandLineAbsStx(
StringLiteralAbsStx(command_line_syntax_str))
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
command=asrt_command.equals_shell_command(
command_line=command_line_str,
arguments=[],
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
expectation = MultiSourceExpectation(
symbol_references=asrt.matches_sequence([
string_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_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 test_failing_validation(self):
# ARRANGE #
symbol_not_an_int = StringSymbolContext.of_constant('SYMBOL_NOT_AN_INT', 'notAnInt')
cases = [
ValidationCase(comparators.EQ.name + ' not a number',
remaining_source(comparators.EQ.name + ' notANumber'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
),
ValidationCase(comparators.EQ.name + ' not an int',
remaining_source(comparators.EQ.name + ' 0.5'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
),
ValidationCase(comparators.EQ.name + ' invalid expression syntax',
remaining_source(comparators.EQ.name + ' (1'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
),
ValidationCase(comparators.EQ.name + ' with symbol references',
remaining_source(
'== {}'.format(symbol_reference_syntax_for_name(symbol_not_an_int.name))
),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
references=asrt.matches_singleton_sequence(
symbol_not_an_int.reference_assertion__string__w_all_indirect_refs_are_strings),
symbols=symbol_not_an_int.symbol_table
),
]
for case in cases:
with self.subTest(case.name):
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
case.source,
input_=integration_check.ARBITRARY_MODEL,
arrangement=arrangement_wo_tcds(
symbols=case.symbols,
),
expectation=Expectation(
ParseExpectation(
source=case.source_assertion,
symbol_references=case.references,
),
ExecutionExpectation(
validation=validation.ValidationAssertions.pre_sds_fails__w_any_msg(),
),
)
)
def test_application(self):
conf = self.configuration
for value in [False, True]:
conf.checker_for_parser_of_full_expr().check__w_source_variants(
self,
arguments=matcher_argument.Constant(value).as_arguments,
input_=conf.arbitrary_model,
arrangement=arrangement_wo_tcds(),
expectation=Expectation(execution=ExecutionExpectation(
main_result=asrt_matching_result.matches(
asrt.equals(value),
trace=_utils.trace_equals(
tree.Node.leaf(logic.CONSTANT_MATCHER, value, (
tree.StringDetail(logic.BOOLEANS[value]),
)))))))
def __init__(self,
name: str,
pgm_and_args: PgmAndArgsAbsStx,
expected_command_driver: Callable[[AssertionResolvingEnvironment], Assertion[CommandDriver]],
symbols: Sequence[SymbolContext] = (),
tcds: TcdsPopulator = tcds_populators.empty(),
mk_arrangement: Callable[[SymbolTable], Arrangement] =
lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl),
):
self.name = name
self.pgm_and_args = pgm_and_args
self.symbols = symbols
self.expected_command_driver = expected_command_driver
self.tcds = tcds
self.mk_arrangement = mk_arrangement
def test_tcds_SHOULD_not_exist_WHEN_flag_for_not_creating_tcds_is_given(self):
def make_primitive(tcds: TestCaseDs) -> MatcherWTrace[int]:
return constant.MatcherWithConstantResult(True)
self._check___single_and_multi(
utils.single_line_arguments(),
ARBITRARY_MODEL,
_constant_line_matcher_type_parser_of_matcher_ddv(
sdv_ddv.MatcherDdvFromPartsTestImpl(
make_primitive,
ValidatorThatAssertsThatTcdsDirsDoesNotDenoteExistingDirectories(self),
)
),
arrangement_wo_tcds(),
Expectation(),
)
def test_two_different_files_w_matcher(self):
# ARRANGE #
file_name__constant = 'file-name-with-constant-matcher'
file_name__w_variations = 'file-name-with-matcher-with-variations'
fm__constant = FileMatcherSymbolContextOfPrimitiveConstant(
'fm_constant', True)
fm__w_variations = 'fm_w_variations'
arguments = args.FilesCondition([
args.FileCondition(
file_name__constant,
fm_args.SymbolReferenceWReferenceSyntax(fm__constant.name)),
args.FileCondition(
file_name__w_variations,
fm_args.SymbolReferenceWReferenceSyntax(fm__w_variations)),
])
# ACT & ASSERT #
CHECKER.check_multi__w_source_variants(
self, arguments.as_arguments,
asrt.matches_sequence([
fm__constant.reference_assertion,
is_reference_to_file_matcher(fm__w_variations),
]), None, [
NExArr(
'FileMatcher with variations should give {}'.format(
expected_result_of_matcher_w_variations),
PrimAndExeExpectation.of_prim__const(
asrt_primitive.files_matches({
PurePosixPath(file_name__constant):
asrt_primitive.is_matcher_that_gives(
fm__constant.result_value),
PurePosixPath(file_name__w_variations):
asrt_primitive.is_matcher_that_gives(
expected_result_of_matcher_w_variations)
})),
arrangement_wo_tcds(
SymbolContext.symbol_table_of_contexts([
fm__constant,
FileMatcherSymbolContext.of_primitive_constant(
fm__w_variations,
expected_result_of_matcher_w_variations),
])),
) for expected_result_of_matcher_w_variations in [False, True]
])
def check__w_max_as_lines_invocations__wo_max_lines_from_iter(
put: unittest.TestCase,
range_expr: Sequence[range_args.Range],
input_and_expected: InputAndExpected,
max_as_lines_invocations: int = 1,
):
arguments = args.filter_line_nums__multi(range_expr)
integration_check.CHECKER__PARSE_SIMPLE__WO_IMPLICIT_MODEL_EVALUATION.check(
put, arguments.as_remaining_source,
model_constructor.of_lines__w_max_invocations(
put,
input_and_expected.input,
max_as_lines_invocations,
), arrangement_wo_tcds(),
expectation_of_successful_execution__check_only_as_lines(
symbol_references=asrt.is_empty_sequence,
output_lines=input_and_expected.expected,
))
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_back_slash_should_not_separate_parts(self):
# ARRANGE #
file_name_with_back_slash = '\\'.join(FILE_NAME_PARTS)
expected_file_names = {
PurePosixPath(file_name_with_back_slash): asrt.is_none
}
source = args.FilesCondition([
args.FileCondition(
surrounded_by_hard_quotes(file_name_with_back_slash)),
])
# ACT & ASSERT #
CHECKER.check__w_source_variants(
self, source.as_arguments, None, arrangement_wo_tcds(),
Expectation(
ParseExpectation(),
ExecutionExpectation(),
primitive=prim_asrt__constant(
asrt_primitive.files_matches(expected_file_names))))
def runTest(self):
invalid_int_expr = range_args.SingleLineRange('1.5')
valid_int_expr = range_args.SingleLineRange('1')
range_expression_cases = [
[invalid_int_expr, valid_int_expr, valid_int_expr],
[valid_int_expr, invalid_int_expr, valid_int_expr],
[valid_int_expr, valid_int_expr, invalid_int_expr],
]
for range_expressions in range_expression_cases:
with self.subTest([str(r) for r in range_expressions]):
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
args.filter_line_nums__multi(
range_expressions).as_remaining_source,
model_constructor.arbitrary(self), arrangement_wo_tcds(),
Expectation(
ParseExpectation(),
ExecutionExpectation(validation=ValidationAssertions.
pre_sds_fails__w_any_msg(), ),
))
