def runTest(self):
# ARRANGE #
string_72_plus = StringSymbolContext.of_constant(
'SYMBOL_72_PLUS',
'72+',
default_restrictions=asrt_data_rest.
is__string__w_all_indirect_refs_are_strings(),
)
string_5 = StringSymbolContext.of_constant(
'SYMBOL_5',
'5',
default_restrictions=asrt_data_rest.
is__string__w_all_indirect_refs_are_strings(),
)
expected = 72 + 5
all_symbols = [string_72_plus, string_5]
value_syntax = StringConcatAbsStx([
string_72_plus.abstract_syntax,
string_5.abstract_syntax,
])
# ACT & ASSERT #
self.conf.instruction_checker.check_parsing__abs_stx__const(
self, self.conf.parser(),
InstructionArgumentsAbsStx.of_int(value_syntax),
self.conf.arrangement(
symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ),
self.conf.expect_success(
symbol_usages=SymbolContext.usages_assertion_of_contexts(
all_symbols),
instruction_settings=asrt_is.matches(
timeout=asrt.equals(expected))))
def runTest(self):
# ARRANGE #
var_to_unset = NameAndValue('var_to_unset', 'value of var to unset')
other_var = NameAndValue('other_var', 'val of other var')
instruction_argument = UnsetVariableArgumentsAbsStx.of_str(
var_to_unset.name, phase_spec=None)
vars_from_defaults_getter = [var_to_unset, other_var]
environ_wo_var_to_unset = NameAndValue.as_dict([other_var])
def get_default_environ() -> Dict[str, str]:
return NameAndValue.as_dict(vars_from_defaults_getter)
def mk_arrangement():
return self.conf.arrangement(
environ=None,
default_environ_getter=get_default_environ,
)
# ACT & ASSERT #
self.conf.instruction_checker.check_parsing__abs_stx(
self, self.conf.parser(), instruction_argument, mk_arrangement,
self.conf.expect_success(instruction_settings=asrt_is.matches(
environ=asrt.equals(environ_wo_var_to_unset))))
def runTest(self):
string_72_plus = StringSymbolContext.of_constant(
'SYMBOL_72_PLUS',
'72+',
default_restrictions=asrt_data_rest.
is__string__w_all_indirect_refs_are_strings(),
)
string_5 = StringSymbolContext.of_constant(
'SYMBOL_5',
'5',
default_restrictions=asrt_data_rest.
is__string__w_all_indirect_refs_are_strings(),
)
expected = 72 + 5
all_symbols = [string_72_plus, string_5]
value_syntax = StringConcatAbsStx([
string_72_plus.abstract_syntax,
string_5.abstract_syntax,
])
CHECKER.check__abs_stx__layout_and_source_variants(
self,
InstructionArgumentsAbsStx.of_int(value_syntax),
Arrangement.phase_agnostic(
symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ),
MultiSourceExpectation.phase_agnostic(
symbol_usages=SymbolContext.usages_assertion_of_contexts(
all_symbols),
instruction_settings=asrt_instr_settings.matches(
timeout=asrt.equals(expected))),
)
def expectation_of_removal_from_phase(
self, phase: Phase, var_to_remove: str) -> ExecutionExpectation:
return ExecutionExpectation.setup_phase_aware(
main_result=asrt.is_none,
instruction_settings=asrt_instr_settings.matches(
environ=asrt.equals(
self.with_removed__as_dict(phase, var_to_remove))))
def expectation_of_addition_to_phase(
self, phase: Phase, var_to_add: EnvVar) -> ExecutionExpectation:
return ExecutionExpectation.setup_phase_aware(
main_result=asrt.is_none,
instruction_settings=asrt_instr_settings.matches(
environ=asrt.equals(self.with_added__as_dict(
phase, var_to_add))))
def expectation(
non_act: Optional[Mapping[str, str]],
the_act: Optional[Mapping[str, str]]) -> ExecutionExpectation[None]:
return ExecutionExpectation.setup_phase_aware(
main_result=asrt.is_none,
instruction_settings=asrt_instr_settings.matches(
environ=asrt.equals(non_act), ),
setup_settings=asrt_setup_settings.matches(
environ=asrt.equals(the_act)))
def runTest(self):
CHECKER.check__abs_stx__layout_and_source_variants(
self,
InstructionArgumentsAbsStx.of_none(),
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
instruction_settings=asrt_instr_settings.matches(
timeout=asrt.is_none)),
)
def expect(
instruction_settings: Optional[Mapping[str, str]],
setup_settings: Optional[Mapping[str, str]],
) -> MultiSourceExpectation:
return MultiSourceExpectation(
instruction_settings=asrt_instr_settings.matches(
environ=asrt.equals(instruction_settings), ),
settings_builder=asrt_setup_settings.matches(
environ=asrt.equals(setup_settings),
stdin=asrt.is_none,
))
def runTest(self):
# ARRANGE #
var_name = 'var_to_unset'
instruction_argument = UnsetVariableArgumentsAbsStx.of_str(
var_name, phase_spec=None)
environ_wo_var_to_unset = {'other_var': 'val of other var'}
def mk_arrangement():
return self.conf.arrangement(environ=dict(environ_wo_var_to_unset))
# ACT & ASSERT #
self.conf.instruction_checker.check_parsing__abs_stx(
self, self.conf.parser(), instruction_argument, mk_arrangement,
self.conf.expect_success(instruction_settings=asrt_is.matches(
environ=asrt.equals(environ_wo_var_to_unset))))
def runTest(self):
# ARRANGE #
var_val = NameAndValue('name', 'value')
instruction_argument = SetVariableArgumentsAbsStx.of_nav(
var_val, phase_spec=Phase.ACT)
expected_environ = {}
empty_environ = {}
def mk_arrangement():
return self.conf.arrangement(environ=dict(empty_environ))
# ACT & ASSERT #
self.conf.instruction_checker.check_parsing__abs_stx(
self, self.conf.parser(), instruction_argument, mk_arrangement,
self.conf.expect_success(instruction_settings=asrt_is.matches(
environ=asrt.equals(expected_environ))))
def runTest(self):
# ARRANGE #
var_name = 'var_to_unset'
other_var = NameAndValue('other_var', 'val of other var')
instruction_argument = UnsetVariableArgumentsAbsStx.of_str(
var_name, phase_spec=Phase.ACT)
environ_w_var_to_unset = {
var_name: 'value of var to unset',
other_var.name: other_var.value
}
def mk_arrangement():
return self.conf.arrangement(environ=dict(environ_w_var_to_unset))
# ACT & ASSERT #
self.conf.instruction_checker.check_parsing__abs_stx(
self, self.conf.parser(), instruction_argument, mk_arrangement,
self.conf.expect_success(instruction_settings=asrt_is.matches(
environ=asrt.equals(environ_w_var_to_unset))))
def runTest(self):
cases = [
NIE(
'constant 5',
5,
StringLiteralAbsStx('5'),
),
NIE(
'constant 5 / quoted',
5,
StringLiteralAbsStx('5', QuoteType.SOFT),
),
NIE(
'constant 75',
75,
StringLiteralAbsStx('75'),
),
NIE(
'python expr',
5,
StringLiteralAbsStx('2+3'),
),
NIE(
'python expr with space',
7,
StringLiteralAbsStx('2*3 + 1', QuoteType.HARD),
),
NIE(
'python expr len',
11,
StringLiteralAbsStx('len("hello world")', QuoteType.HARD),
),
]
for case in cases:
with self.subTest(case.name):
CHECKER.check__abs_stx__layout_and_source_variants(
self,
InstructionArgumentsAbsStx.of_int(case.input_value),
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
instruction_settings=asrt_instr_settings.matches(
timeout=asrt.equals(case.expected_value))),
)
def test_populate_environ(self):
default_from_default_getter = {'default': 'value of default'}
default_environs = {'in_environs': 'value of var in environs'}
def default_environ_getter() -> Dict[str, str]:
return default_from_default_getter
self._check(
PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION,
utils.single_line_source(),
sut.Arrangement(
default_environ_getter=default_environ_getter,
process_execution_settings=ProcessExecutionSettings.
from_non_immutable(environ=default_environs),
),
sut.Expectation(instruction_settings=asrt_instr_settings.matches(
environ=asrt.equals(default_environs),
return_value_from_default_getter=asrt.equals(
default_from_default_getter)),
proc_exe_settings=asrt_pes.matches(
environ=asrt.equals(default_environs))),
)
def test_populate_environ(self):
default_from_default_getter = {'default': 'value of default'}
default_environs = {'in_environs': 'value of var in environs'}
def default_environ_getter() -> Dict[str, str]:
return dict(default_from_default_getter)
self._check_source_and_exe_variants(
PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION,
Arrangement.phase_agnostic(
default_environ_getter=default_environ_getter,
process_execution_settings=ProcessExecutionSettings.from_non_immutable(environ=default_environs),
),
MultiSourceExpectation.phase_agnostic(
instruction_settings=asrt_instr_settings.matches(
environ=asrt.equals(default_environs),
return_value_from_default_getter=asrt.equals(default_from_default_getter)
),
proc_exe_settings=asrt_pes.matches(
environ=asrt.equals(default_environs)
)
),
)
def runTest(self):
# ARRANGE #
var_in_default = NameAndValue('var_in_default',
'value of var in default')
var_to_set = NameAndValue('var_to_set', 'value')
expected_environ = NameAndValue.as_dict([var_in_default, var_to_set])
def get_default_environ() -> Dict[str, str]:
return NameAndValue.as_dict([var_in_default])
instruction_argument = SetVariableArgumentsAbsStx.of_nav(
var_to_set, phase_spec=None)
def mk_arrangement():
return self.conf.arrangement(
environ=None,
default_environ_getter=get_default_environ,
)
# ACT & ASSERT #
self.conf.instruction_checker.check_parsing__abs_stx(
self, self.conf.parser(), instruction_argument, mk_arrangement,
self.conf.expect_success(instruction_settings=asrt_is.matches(
environ=asrt.equals(expected_environ))))
