def runTest(self):
# ARRANGE #
cases = [
NameAndValue(
'pre sds',
(
RelOptionType.REL_HDS_CASE,
ValidationAssertions.pre_sds_fails__w_any_msg(),
),
),
NameAndValue(
'post sds',
(
RelOptionType.REL_ACT,
ValidationAssertions.post_sds_fails__w_any_msg(),
),
),
]
for case in cases:
with self.subTest(case.name):
CHECKER.check__w_source_variants(
self,
command_line(
'program',
program_arguments.existing_path(
path_arguments.RelOptPathArgument('name', case.value[0]),
)
).as_str,
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
validation=case.value[1],
),
)
def dir_partition_cases_for_validation(dst_path_symbol_name: str,
) -> Sequence[NArrEx[RelativityOptionConfiguration, ValidationAssertions]]:
return [
NArrEx(
DirectoryStructurePartition.HDS.name,
_relativity_conf_for_symbol(dst_path_symbol_name, RelOptionType.REL_HDS_CASE),
ValidationAssertions.pre_sds_fails__w_any_msg(),
),
NArrEx(
DirectoryStructurePartition.NON_HDS.name,
_relativity_conf_for_symbol(dst_path_symbol_name, RelOptionType.REL_ACT),
ValidationAssertions.post_sds_fails__w_any_msg(),
),
]
def _expect_validation_error_and_symbol_usages(
relativity_option_conf: rel_opt_conf.RelativityOptionConfiguration,
expected_symbol_usage: list) -> MultiSourceExpectation:
expected_symbol_usages_assertion = asrt.matches_sequence(
expected_symbol_usage)
if relativity_option_conf.exists_pre_sds:
return MultiSourceExpectation.phase_agnostic(
validation=ValidationAssertions.pre_sds_fails__w_any_msg(),
symbol_usages=expected_symbol_usages_assertion,
)
else:
return MultiSourceExpectation.phase_agnostic(
validation=ValidationAssertions.post_sds_fails__w_any_msg(),
symbol_usages=expected_symbol_usages_assertion,
)
def phase_agnostic_2(
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(),
main_side_effects_on_files: TcdsExpectation = TcdsExpectation(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
) -> 'MultiSourceExpectation[T]':
return MultiSourceExpectation.phase_agnostic(
validation,
main_result,
main_raises_hard_error,
symbol_usages,
symbols_after_main,
main_side_effects_on_files.sds,
main_side_effects_on_files.tcds,
main_side_effects_on_files.case_home,
main_side_effect_on_environment_variables,
proc_exe_settings,
instruction_settings,
instruction_environment,
)
def setup_phase_aware(
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(),
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
setup_settings: Assertion[Optional[SettingsBuilderAssertionModel]] = asrt.is_none,
) -> 'MultiSourceExpectation[T]':
return MultiSourceExpectation(
MainMethodType.SETUP_PHASE_AWARE,
validation,
main_result,
main_raises_hard_error,
symbol_usages,
symbols_after_main,
main_side_effects_on_sds,
side_effects_on_tcds,
side_effects_on_hds,
main_side_effect_on_environment_variables,
proc_exe_settings,
instruction_settings,
instruction_environment,
setup_settings,
)
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 phase_agnostic(
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
) -> 'ExecutionExpectation[T]':
return ExecutionExpectation(
MainMethodType.PHASE_AGNOSTIC,
validation,
main_result,
main_raises_hard_error,
main_side_effects_on_sds,
side_effects_on_tcds,
side_effects_on_hds,
main_side_effect_on_environment_variables,
proc_exe_settings,
instruction_settings,
instruction_environment,
asrt.is_none,
)
def __init__(self,
main_method_type: MainMethodType,
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
setup_settings: Assertion[Optional[SettingsBuilderAssertionModel]] = asrt.is_none,
):
self.main_method_type = main_method_type
self.validation = validation
self.main_result = main_result
self.main_raises_hard_error = main_raises_hard_error
self.proc_exe_settings = proc_exe_settings
self.instruction_settings = instruction_settings
self.main_side_effects_on_sds = main_side_effects_on_sds
self.side_effects_on_tcds = side_effects_on_tcds
self.side_effects_on_hds = side_effects_on_hds
self.main_side_effect_on_environment_variables = main_side_effect_on_environment_variables
self.instruction_application_environment = instruction_environment
self.setup_settings = setup_settings
def test_fail_due_to_unexpected_result_from__validate_post_sds(self):
self._check_source_and_exe_variants__failing_assertions(
PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION,
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
validation=ValidationAssertions.post_sds_fails()
),
)
def __init__(
self,
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[OUTPUT] = asrt.anything_goes(),
is_hard_error: Optional[Assertion[TextRenderer]] = None,
):
self.validation = validation
self.main_result = main_result
self.is_hard_error = is_hard_error
def test_fail_due_to_unexpected_result_from_post_sds_validation(self):
self._check_raises_test_error__single_and_multi(
ConstantParser(_MATCHER_THAT_MATCHES),
Expectation(
execution=ExecutionExpectation(
validation=ValidationAssertions.post_sds_fails(),
),
)
)
def test_quoted_tokens(self):
# ARRANGE #
regex_str = '.* regex'
matches_for_case_sensitive = [' regex', 'before regex after']
option_cases = [
option_case_for_no_option(
_AssertPattern(regex_str,
matching_strings=matches_for_case_sensitive,
non_matching_string=' REGEX')
),
option_case_for_ignore_case(
_AssertPattern(regex_str,
matching_strings=matches_for_case_insensitive(matches_for_case_sensitive),
non_matching_string='regex')
),
]
text_on_following_line = 'text on following line'
source_cases = [
SourceCase(
'soft quotes',
source=
Arguments('{regex}'.format(
regex=surrounded_by_soft_quotes(regex_str),
)),
source_assertion=
assert_token_stream(is_null=asrt.is_true),
),
SourceCase(
'hard quotes, and text on following line',
source=
Arguments('{regex}'.format(
regex=surrounded_by_hard_quotes(regex_str),
),
following_lines=[text_on_following_line]),
source_assertion=
assert_token_stream(
remaining_source=asrt.equals('\n' + text_on_following_line)),
),
]
# ACT & ASSERT #
check_many(self,
Arrangement(),
source_cases,
ExpectationExceptPattern(
validation=ValidationAssertions.all_passes()
),
option_cases,
)
def test_symbol_references(self):
# ARRANGE #
star_string_symbol = StringSymbolContext.of_constant('STAR_SYMBOL', '* ')
regex_str = '.* regex'
regex_arg_str = '.{star}regex'.format(
star=symbol_reference_syntax_for_name(star_string_symbol.name),
)
matches_for_case_sensitive = [' regex', 'before regex after']
option_cases = [
option_case_for_no_option(
_AssertPattern(regex_str,
matching_strings=matches_for_case_sensitive,
non_matching_string=' REGEX')
),
option_case_for_ignore_case(
_AssertPattern(regex_str,
matching_strings=matches_for_case_insensitive(matches_for_case_sensitive),
non_matching_string='regex')
),
]
source_cases = [
SourceCase('single invalid star',
Arguments(regex_arg_str),
assert_token_stream(is_null=asrt.is_true)
),
SourceCase('invalid stars at start of regex',
Arguments(surrounded_by_soft_quotes(regex_arg_str)),
assert_token_stream(is_null=asrt.is_true)
),
]
arrangement = Arrangement(
symbols=star_string_symbol.symbol_table
)
expectation = ExpectationExceptPattern(
references=asrt.matches_sequence([
is_reference_to__regex_string_part(star_string_symbol.name),
]),
validation=ValidationAssertions.all_passes(),
)
# ACT & ASSERT #
check_many(self,
arrangement,
source_cases,
expectation,
option_cases,
)
def __init__(self,
pattern: Assertion[Pattern] = asrt.anything_goes(),
token_stream: Assertion[TokenStream] = asrt.anything_goes(),
validation: ValidationAssertions = ValidationAssertions.all_passes(),
references: Assertion[Sequence[SymbolReference]] = asrt.is_empty_sequence,
):
self.pattern = pattern
self.references = references
self.validation = validation
self.token_stream = token_stream
def failing_integer_validation_cases(symbol_in_integer_name: str = 'symbol_in_integer'
) -> Sequence[IntegerValidationCase]:
non_int_string_symbol = StringSymbolContext.of_constant(
symbol_in_integer_name,
'tre'
)
non_iterable_string_symbol = StringSymbolContext.of_constant(
symbol_in_integer_name,
'1'
)
constant_string_cases = [
IntegerValidationCase('failing validation/pre sds: ' + expr_str,
expr_str,
[],
[],
validation.PRE_SDS_FAILURE_EXPECTATION,
validation.ValidationAssertions.pre_sds_fails__w_any_msg(),
)
for expr_str in
_PRE_SDS_VALIDATION_FAILURE__CONSTANT_STRINGS
]
string_with_symbol_cases = [
IntegerValidationCase('failing validation/pre sds: non-int string ref',
symbol_reference_syntax_for_name(non_int_string_symbol.name),
[non_int_string_symbol],
[is_reference_to_symbol_in_expression(non_int_string_symbol.name)],
validation.PRE_SDS_FAILURE_EXPECTATION,
ValidationAssertions.pre_sds_fails__w_any_msg(),
),
IntegerValidationCase('failing validation/pre sds: non-iterable string ref',
'len({})'.format(symbol_reference_syntax_for_name(non_iterable_string_symbol.name)),
[non_iterable_string_symbol],
[is_reference_to_symbol_in_expression(non_iterable_string_symbol.name)],
validation.PRE_SDS_FAILURE_EXPECTATION,
ValidationAssertions.pre_sds_fails__w_any_msg(),
),
]
return constant_string_cases + string_with_symbol_cases
def runTest(self):
for value_case in INVALID_INT_VALUES:
CHECKER.check__abs_stx__layout_and_source_variants(
self,
InstructionArgumentsAbsStx.of_int(
StringLiteralAbsStx(value_case)),
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
validation=ValidationAssertions.pre_sds_fails__w_any_msg(
)),
sub_test_identifiers={'value_case': value_case},
)
def runTest(self):
failure_message = 'failure'
failing_validation_result = asrt_validation.new_single_string_text_for_test(
failure_message)
line_matcher_symbol_name = 'line_matcher_with_failing_validation'
asserted_symbol_references = asrt.matches_sequence(
[is_reference_to_line_matcher(line_matcher_symbol_name)])
validation_cases = [
NEA('failure pre sds',
expected=Expectation(
ParseExpectation(
symbol_references=asserted_symbol_references, ),
ExecutionExpectation(
validation=ValidationAssertions.pre_sds_fails(
asrt.equals(failure_message)), ),
),
actual=ConstantDdvValidator(
pre_sds_result=failing_validation_result)),
NEA('failure post sds',
expected=Expectation(
ParseExpectation(
symbol_references=asserted_symbol_references, ),
ExecutionExpectation(validation=ValidationAssertions.
post_sds_fails__w_any_msg(), ),
),
actual=ConstantDdvValidator(
post_sds_result=failing_validation_result)),
]
for case in validation_cases:
symbols = LineMatcherSymbolContext.of_sdv(
line_matcher_symbol_name,
successful_matcher_with_validation(case.actual)).symbol_table
for quantifier in Quantifier:
arguments_constructor = arguments_building.ImplicitActualFileArgumentsConstructor(
CommonArgumentsConstructor(),
arguments_building.
LineMatchesAssertionArgumentsConstructor(
quantifier, line_matcher_symbol_name))
for expectation_type in ExpectationType:
arguments = arguments_constructor.apply(expectation_type)
source = test_configuration.arguments_for(
arguments).as_remaining_source
with self.subTest(case=case.name,
expectation_type=expectation_type,
quantifier=quantifier):
self._check(source=source,
model=model_constructor.arbitrary(self),
arrangement=Arrangement(symbols=symbols),
expectation=case.expected)
def failing_regex_validation_cases(
symbol_in_regex_name: str = 'symbol_in_regex'
) -> Sequence[RegexValidationCase]:
post_sds_path = PathDdvSymbolContext.of_no_suffix(symbol_in_regex_name,
RelOptionType.REL_ACT)
return [
RegexValidationCase(
'failing validation/pre sds',
'*',
[],
[],
ValidationAssertions.pre_sds_fails__w_any_msg(),
),
RegexValidationCase(
'failing validation/post sds',
'*' + symbol_reference_syntax_for_name(post_sds_path.name),
[post_sds_path],
[is_reference_to__regex_string_part(post_sds_path.name)],
ValidationAssertions.post_sds_fails__w_any_msg(),
),
]
def __init__(
self,
symbol_name: str,
actual: ValidationActual,
):
self._symbol_context = StringSourceSymbolContext.of_sdv(
symbol_name,
sdvs.StringSourceSdvConstantTestImpl(
ddvs.StringSourceDdvWoResolvingTestImpl(
ddv_validators.constant(actual))))
self.syntax = self._symbol_context.abstract_syntax
self._expectation = validation.Expectation.corresponding_to(actual)
self._assertions = ValidationAssertions.corresponding_to(actual)
def of_exe(
validation: ValidationAssertions = ValidationAssertions.all_passes(),
main_result: Assertion[OUTPUT] = asrt.anything_goes(),
is_hard_error: Optional[Assertion[TextRenderer]] = None,
) -> 'PrimAndExeExpectation[PRIMITIVE, OUTPUT]':
return PrimAndExeExpectation(
ExecutionExpectation(
validation=validation,
main_result=main_result,
is_hard_error=is_hard_error,
),
prim_asrt__any,
)
def runTest(self):
# ARRANGE #
cases = [
NArrEx(
'pre SDS validation failure SHOULD cause validation error',
RelOptionType.REL_HDS_CASE,
MultiSourceExpectation.phase_agnostic(
validation=ValidationAssertions.pre_sds_fails__w_any_msg()
),
),
NArrEx(
'post SDS validation failure SHOULD cause main error',
RelOptionType.REL_ACT,
MultiSourceExpectation.phase_agnostic(
validation=ValidationAssertions.post_sds_fails__w_any_msg()
),
),
]
for case in cases:
program_with_ref_to_non_existing_file = program_abs_stx.ProgramOfExecutableFileCommandLineAbsStx(
path_abs_stx.RelOptPathAbsStx(case.arrangement, 'non-existing-file')
)
instruction_syntax = instr_abs_stx.create_w_explicit_contents(
path_abs_stx.DefaultRelPathAbsStx('dst-file'),
string_source_abs_stx.StringSourceOfProgramAbsStx(ProcOutputFile.STDOUT,
program_with_ref_to_non_existing_file,
ignore_exit_code=False)
)
# ACT & ASSERT #
for phase_is_after_act in [False, True]:
checker = integration_check.checker(phase_is_after_act)
with self.subTest(phase_is_after_act=phase_is_after_act,
step=case.name):
checker.check__abs_stx__std_layouts_and_source_variants(
self,
instruction_syntax,
Arrangement.phase_agnostic(),
case.expectation,
)
def _expect_failure_in(
step_of_expected_failure: Step) -> MultiSourceExpectation:
symbol_usages_expectation = asrt.is_sequence_of(
asrt.is_instance(SymbolReference))
if step_of_expected_failure is Step.VALIDATE_PRE_SDS:
return MultiSourceExpectation.phase_agnostic(
validation=ValidationAssertions.pre_sds_fails__w_any_msg(),
symbol_usages=symbol_usages_expectation,
)
elif step_of_expected_failure is Step.VALIDATE_POST_SDS:
return MultiSourceExpectation.phase_agnostic(
validation=ValidationAssertions.post_sds_fails__w_any_msg(),
symbol_usages=symbol_usages_expectation,
)
elif step_of_expected_failure is Step.MAIN:
return MultiSourceExpectation.phase_agnostic(
main_result=IS_FAILURE,
symbol_usages=symbol_usages_expectation,
)
else:
raise ValueError('Unknown {}: {}'.format(Step,
step_of_expected_failure))
def test_ERROR_when_file_does_not_exist__without_explicit_destination__hds(self):
for execution_checker in _EXECUTION_CHECKERS:
for relativity_option in source_relativity_options__hds():
with self.subTest(parser=execution_checker.name,
relativity=relativity_option.test_case_description):
execution_checker.value.check(
self,
args.copy(
relativity_option.path_argument_of_rel_name('source-that-do-not-exist')
).as_remaining_source,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(),
symbols=relativity_option.symbols.in_arrangement(),
),
Expectation.phase_agnostic_2(
validation=ValidationAssertions.pre_sds_fails__w_any_msg(),
symbol_usages=relativity_option.symbols.usages_expectation(),
),
)
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
for maybe_with_transformer_option in TRANSFORMER_OPTION_ALTERNATIVES:
for maybe_full_match in FULL_MATCH_OPTION_ALTERNATIVES:
with self.subTest(maybe_with_transformer_option=maybe_with_transformer_option,
maybe_full_match=maybe_full_match):
self._check_with_source_variants(
test_configuration.arguments_for(
args('{maybe_with_transformer_option} {maybe_not} {matches} {maybe_full_match} **',
maybe_with_transformer_option=maybe_with_transformer_option,
maybe_full_match=maybe_full_match,
maybe_not=maybe_not.nothing__if_positive__not_option__if_negative)),
model_constructor.empty(self),
Arrangement(),
Expectation(
execution=ExecutionExpectation(
validation=ValidationAssertions.pre_sds_fails__w_any_msg()
),
)
)
def test_SHOULD_match_WHEN_post_sds_validation_fails_expectedly_but_primitive_value_is_unexpected(
self):
# ARRANGE #
sdv_of_actual = RegexSdvConstantTestImpl(
ARBITRARY_PATTERN,
value_validator=ConstantDdvValidator(
post_sds_result=asrt_validation.
new_single_string_text_for_test('expected failure')),
)
assertion_to_check = sut.matches_regex_sdv(
dir_dependencies=DirDependencies.NONE,
validation=ValidationAssertions.post_sds_fails(),
primitive_value=check_of_primitive_value_fails_expectedly,
)
# ACT & ASSERT #
assertion_to_check.apply_without_message(self, sdv_of_actual)
def __init__(self,
main_method_type: MainMethodType,
validation_pre_sds: ValidationResultAssertion = asrt.is_none,
validation_post_sds: ValidationResultAssertion = asrt.is_none,
main_result: Assertion[T] = asrt.anything_goes(),
main_raises_hard_error: bool = False,
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
symbols_after_main: Assertion[SymbolTable] = asrt.anything_goes(),
main_side_effects_on_sds: Assertion[SandboxDs] = asrt.anything_goes(),
side_effects_on_tcds: Assertion[TestCaseDs] = asrt.anything_goes(),
side_effects_on_hds: Assertion[pathlib.Path] = asrt.anything_goes(),
source: Assertion[ParseSource] = asrt.anything_goes(),
main_side_effect_on_environment_variables: Assertion[Dict[str, str]] = asrt.anything_goes(),
proc_exe_settings: Assertion[ProcessExecutionSettings]
= asrt.is_instance(ProcessExecutionSettings),
instruction_settings: Assertion[InstructionSettings]
= asrt.is_instance(InstructionSettings),
assertion_on_instruction_environment:
Assertion[InstructionApplicationEnvironment] = asrt.anything_goes(),
setup_settings: Assertion[Optional[SettingsBuilderAssertionModel]] = asrt.is_none,
):
super().__init__(
main_method_type,
ValidationAssertions(validation_pre_sds,
validation_post_sds),
main_result,
main_raises_hard_error,
symbol_usages,
symbols_after_main,
main_side_effects_on_sds,
side_effects_on_tcds,
side_effects_on_hds,
main_side_effect_on_environment_variables,
proc_exe_settings,
instruction_settings,
assertion_on_instruction_environment,
setup_settings,
)
self.source = source
def test_string_literal(self):
for other_valid_file_spec_case in OTHER_VALID_FILE_SPECS:
for file_name_case in INVALID_FILE_NAMES:
file_name_abs_stx = StringLiteralAbsStx(file_name_case.value, QuoteType.HARD)
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(),
MultiSourceExpectation(
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_symbol_references_with_dir_dependencies(self):
# ARRANGE #
path_symbol_name = 'PATH_SYMBOL'
regex_source_string = (symbol_reference_syntax_for_name(self.STAR_STRING_SYMBOL.name) +
symbol_reference_syntax_for_name(path_symbol_name))
expectation = Expectation(
references=asrt.matches_sequence([
is_reference_to__regex_string_part(self.STAR_STRING_SYMBOL.name),
is_reference_to__regex_string_part(path_symbol_name),
]),
validation=ValidationAssertions.post_sds_fails__w_any_msg(),
token_stream=assert_token_stream(is_null=asrt.is_true),
)
rel_opt_cases = [
RelOptionType.REL_HDS_CASE,
RelOptionType.REL_CWD,
RelOptionType.REL_ACT,
]
for rel_opt in rel_opt_cases:
path_symbol = PathDdvSymbolContext.of_no_suffix(path_symbol_name, rel_opt)
arrangement = Arrangement(
symbols=SymbolContext.symbol_table_of_contexts([
self.STAR_STRING_SYMBOL,
path_symbol,
])
)
# ACT & ASSERT #
self._check(regex_source_string,
arrangement,
expectation,
)
def expectation(self) -> ValidationAssertions:
return ValidationAssertions.corresponding_to(self.actual)
def of_expectation(
expectation: Expectation,
tcds: TestCaseDs,
) -> Assertion[DdvValidator]:
return DdvValidationAssertion(
tcds, ValidationAssertions.of_expectation(expectation))
