def __init__(self, test_case: TestCaseOfInstructions,
action_to_check: Sequence[SymbolUsage],
builtin_symbols: Optional[SymbolTable]):
self._test_case = test_case
self._action_to_check = action_to_check
self._builtin_symbols = symbol_table.symbol_table_from_none_or_value(
builtin_symbols)
def __init__(self,
pre_contents_population_action: TcdsAction = TcdsAction(),
hds_contents: hds_populators.HdsPopulator = hds_populators.empty(),
sds_contents: sds_populator.SdsPopulator = sds_populator.empty(),
non_hds_contents: non_hds_populator.NonHdsPopulator = non_hds_populator.empty(),
tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(),
os_services: OsServices = os_services_access.new_for_current_os(),
process_execution_settings: ProcessExecutionSettings = proc_exe_env_for_test(),
default_environ_getter: DefaultEnvironGetter = get_empty_environ,
post_sds_population_action: TcdsAction = TcdsAction(),
symbols: SymbolTable = None,
fs_location_info: FileSystemLocationInfo = ARBITRARY_FS_LOCATION_INFO,
):
super().__init__(hds_contents=hds_contents,
process_execution_settings=process_execution_settings,
default_environ_getter=default_environ_getter)
self.pre_contents_population_action = pre_contents_population_action
self.sds_contents = sds_contents
self.non_hds_contents = non_hds_contents
self.tcds_contents = tcds_contents
self.post_sds_population_action = post_sds_population_action
self.os_services = os_services
self.process_execution_settings = process_execution_settings
self.symbols = symbol_table_from_none_or_value(symbols)
self.fs_location_info = fs_location_info
def matches_resolver_of_program(references: ValueAssertion[Sequence[SymbolReference]],
resolved_program_value: ValueAssertion[DirDependentValue],
custom: ValueAssertion[ProgramResolver] = asrt.anything_goes(),
symbols: SymbolTable = None) -> ValueAssertion[rs.SymbolValueResolver]:
return matches_resolver(is_resolver_of_program_type(),
references,
asrt.is_instance_with(ProgramValue, resolved_program_value),
custom,
symbol_table_from_none_or_value(symbols))
def matches_resolver_of_line_matcher(references: ValueAssertion[Sequence[SymbolReference]],
resolved_value: ValueAssertion[LineMatcherValue],
custom: ValueAssertion[LineMatcherResolver] = asrt.anything_goes(),
symbols: SymbolTable = None) -> ValueAssertion[rs.SymbolValueResolver]:
return matches_resolver(is_resolver_of_line_matcher_type(),
references,
asrt.is_instance_with(LineMatcherValue, resolved_value),
custom,
symbol_table_from_none_or_value(symbols))
def __init__(self,
sds_contents_before: sds_populator.SdsPopulator = sds_populator.empty(),
pre_contents_population_action: SdsAction = SdsAction(),
pre_action_action: SdsAction = SdsAction(),
symbols: SymbolTable = None):
self.pre_contents_population_action = pre_contents_population_action
self.sds_contents_before = sds_contents_before
self.pre_action_action = pre_action_action
self.symbols = symbol_table_from_none_or_value(symbols)
def matches_sdv_of_path(
references: Assertion[Sequence[SymbolReference]],
ddv: Assertion[PathDdv],
custom: Assertion[PathSdv] = asrt.anything_goes(),
symbols: Optional[SymbolTable] = None
) -> Assertion[SymbolDependentValue]:
return matches_sdv(asrt.is_instance(PathSdv), references,
asrt.is_instance_with(PathDdv, ddv), custom,
symbol_table_from_none_or_value(symbols))
def matches_regex_resolver(
primitive_value: Callable[[HomeAndSds], ValueAssertion[Pattern]] = lambda tcds: asrt.anything_goes(),
references: ValueAssertion[Sequence[SymbolReference]] = asrt.is_empty_sequence,
dir_dependencies: DirDependencies = DirDependencies.NONE,
validation: ValidationExpectation = all_validations_passes(),
symbols: symbol_table.SymbolTable = None,
tcds: HomeAndSds = fake_home_and_sds(),
) -> ValueAssertion[RegexResolver]:
symbols = symbol_table.symbol_table_from_none_or_value(symbols)
def resolve_value(resolver: RegexResolver):
return resolver.resolve(symbols)
def on_resolve_primitive_value(tcds_: HomeAndSds) -> ValueAssertion[Pattern]:
return asrt.is_instance_with(RE_PATTERN_TYPE,
primitive_value(tcds_))
resolved_value_assertion = matches_multi_dir_dependent_value(
dir_dependencies,
on_resolve_primitive_value,
tcds,
)
def validation_is_successful(value: RegexValue) -> bool:
validator = value.validator()
return (validator.validate_pre_sds_if_applicable(tcds.hds) is None and
validator.validate_post_sds_if_applicable(tcds) is None)
return asrt.is_instance_with(
RegexResolver,
asrt.and_([
asrt.sub_component(
'references',
resolver_structure.get_references,
references),
asrt.sub_component(
'resolved value',
resolve_value,
asrt.and_([
asrt.sub_component(
'validator',
lambda value: value.validator(),
asrt.is_instance_with(PreOrPostSdsValueValidator,
PreOrPostSdsValueValidationAssertion(
tcds,
validation))
),
asrt.if_(
validation_is_successful,
resolved_value_assertion
),
]),
)
])
)
def test_symbol_table_from_none_or_value_SHOULD_give_given_table_WHEN_argument_is_not_none(self):
# ARRANGE #
symbol = NameAndValue('symbol name',
ASymbolTableValue('symbol value'))
symbol_table = sut.singleton_symbol_table(sut.Entry(symbol.name,
symbol.value))
# ACT #
actual = sut.symbol_table_from_none_or_value(symbol_table)
# ASSERT #
_assert_table_contains_single_value(self, actual, symbol)
def matches_resolver(resolver_type: ValueAssertion[rs.SymbolValueResolver],
references: ValueAssertion[Sequence[SymbolReference]],
resolved_value: ValueAssertion,
custom: ValueAssertion[rs.SymbolValueResolver] = asrt.anything_goes(),
symbols: SymbolTable = None) -> ValueAssertion[rs.SymbolValueResolver]:
return _MatchesSymbolValueResolver(resolver_type,
references,
resolved_value,
custom,
symbol_table_from_none_or_value(symbols))
def matches_sdv(sdv_type: Assertion[SymbolDependentValue],
references: Assertion[Sequence[SymbolReference]],
resolved_value: Assertion[DirDependentValue],
custom: Assertion[SymbolDependentValue] = asrt.anything_goes(),
symbols: Optional[SymbolTable] = None) -> Assertion[SymbolDependentValue]:
return _MatchesSdv(sdv_type,
references,
resolved_value,
custom,
symbol_table_from_none_or_value(symbols))
def __init__(self,
sds_contents_before: sds_populator.
SdsPopulator = sds_populator.empty(),
pre_contents_population_action: SdsAction = SdsAction(),
pre_action_action: SdsAction = SdsAction(),
symbols: SymbolTable = None):
self.pre_contents_population_action = pre_contents_population_action
self.sds_contents_before = sds_contents_before
self.pre_action_action = pre_action_action
self.symbols = symbol_table_from_none_or_value(symbols)
def __init__(self,
tcds: TcdsArrangementPostAct = TcdsArrangementPostAct(),
symbols: Optional[SymbolTable] = None,
process_execution: ProcessExecutionArrangement = ProcessExecutionArrangement(),
default_environ_getter: DefaultEnvironGetter = get_empty_environ,
):
self.symbols = symbol_table_from_none_or_value(symbols)
self.tcds = tcds
self.process_execution = process_execution
self.default_environ_getter = default_environ_getter
def __init__(self,
hds_contents: home_populators.HomePopulator = home_populators.empty(),
environ: dict = None,
timeout_in_seconds: int = None,
atc_process_executor: AtcOsProcessExecutor = DEFAULT_ATC_OS_PROCESS_EXECUTOR,
symbol_table: SymbolTable = None,
):
self.hds_contents = hds_contents
self.environ = {} if environ is None else environ
self.timeout_in_seconds = timeout_in_seconds
self.atc_process_executor = atc_process_executor
self.symbol_table = symbol_table_from_none_or_value(symbol_table)
def __init__(self,
hds: HomeDs = fake_hds(),
environ: Optional[Dict[str, str]] = None,
timeout_in_seconds: Optional[int] = 30,
symbols: Optional[SymbolTable] = None,
mem_buff_size: int = 2 ** 10,
):
self._hds = hds
self._environ = environ
self._timeout_in_seconds = timeout_in_seconds
self._symbols = symbol_table_from_none_or_value(symbols)
self.mem_buff_size = mem_buff_size
def sds_with_act_as_curr_dir(contents: sds_populator.SdsPopulator = sds_populator.empty(),
pre_contents_population_action: SdsAction = SdsAction(),
symbols: SymbolTable = None,
) -> PathResolvingEnvironmentPostSds:
with tempfile.TemporaryDirectory(prefix=program_info.PROGRAM_NAME + '-test-sds-') as sds_root_dir:
sds = sds_module.construct_at(resolved_path_name(sds_root_dir))
environment = PathResolvingEnvironmentPostSds(sds, symbol_table_from_none_or_value(symbols))
with preserved_cwd():
os.chdir(str(sds.act_dir))
pre_contents_population_action.apply(environment)
contents.populate_sds(sds)
yield environment
def matches_sdv_of_files_condition_constant(
references: Assertion[
Sequence[SymbolReference]] = asrt.anything_goes(),
primitive_value: Assertion[FilesCondition] = asrt.anything_goes(),
symbols: SymbolTable = None) -> Assertion[SymbolDependentValue]:
return matches_sdv(
asrt.is_instance(FilesConditionSdv), references,
asrt.is_instance_with(
FilesConditionDdv,
asrt_logic.matches_logic_ddv(lambda tcds: asrt.is_instance_with(
FilesCondition, primitive_value))), asrt.anything_goes(),
symbol_table_from_none_or_value(symbols))
def matches_sdv_of_string_transformer_constant(
references: Assertion[
Sequence[SymbolReference]] = asrt.anything_goes(),
primitive_value: Assertion[StringTransformer] = asrt.anything_goes(),
symbols: SymbolTable = None) -> Assertion[SymbolDependentValue]:
return matches_sdv(
asrt.is_instance(StringTransformerSdv), references,
asrt.is_instance_with(
StringTransformerDdv,
asrt_logic.matches_logic_ddv(lambda tcds: asrt.is_instance_with(
StringTransformer, primitive_value))), asrt.anything_goes(),
symbol_table_from_none_or_value(symbols))
def matches_sdv_of_program(
references: Assertion[Sequence[SymbolReference]],
primitive_value: Callable[[TestCaseDs], Assertion[Program]],
symbols: Optional[SymbolTable] = None
) -> Assertion[SymbolDependentValue]:
return matches_sdv(
asrt.is_instance(ProgramSdv), references,
asrt.is_instance_with(
ProgramDdv,
asrt_logic.matches_logic_ddv(lambda tcds: asrt.is_instance_with(
Program, primitive_value(tcds)))), asrt.anything_goes(),
symbol_table_from_none_or_value(symbols))
def __init__(
self,
act_phase_instructions: List[ActPhaseInstruction],
home_act_dir_contents: DirContents = empty_dir_contents(),
environ: Optional[Mapping[str, str]] = None,
symbols: Optional[SymbolTable] = None,
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
self.symbols = symbol_table_from_none_or_value(symbols)
self.home_act_dir_contents = home_act_dir_contents
self.act_phase_instructions = act_phase_instructions
self.environ = environ
self.symbol_usages = symbol_usages
def matches_matcher_sdv(
primitive_value: Assertion[MatcherWTrace] = asrt.anything_goes(),
references: Assertion[
Sequence[SymbolReference]] = asrt.is_empty_sequence,
symbols: SymbolTable = None,
tcds: TestCaseDs = fake_tcds(),
) -> Assertion[SymbolDependentValue]:
return matches_sdv(
asrt.is_instance(MatcherSdv), references,
asrt.is_instance_with(
MatcherDdv,
asrt_logic.matches_matcher_ddv(lambda tcds_: primitive_value,
tcds)), asrt.anything_goes(),
symbol_table_from_none_or_value(symbols))
def __init__(
self,
tcds: Optional[TcdsArrangementPreAct] = None,
symbols: Optional[SymbolTable] = None,
process_execution:
ProcessExecutionArrangement = ProcessExecutionArrangement(
process_execution_settings=proc_exe_env_for_test()),
atc_exe_input: AtcExeInputArr = AtcExeInputArr(),
mem_buff_size: int = 2**10,
):
self.symbol_table = symbol_table_from_none_or_value(symbols)
self.tcds = tcds
self.process_execution = process_execution
self.atc_exe_input = atc_exe_input
self.mem_buff_size = mem_buff_size
def __init__(
self,
symbols: Optional[SymbolTable] = None,
tcds: Optional[TcdsArrangement] = None,
process_execution:
ProcessExecutionArrangement = ProcessExecutionArrangement(),
mem_buff_size: int = 2**10,
):
"""
:param tcds: Not None iff TCDS is used (and must thus be created)
"""
self.symbols = symbol_table_from_none_or_value(symbols)
self.tcds = tcds
self.process_execution = process_execution
self.mem_buff_size = mem_buff_size
def sds_with_act_as_curr_dir(
contents: sds_populator.SdsPopulator = sds_populator.empty(),
pre_contents_population_action: SdsAction = SdsAction(),
symbols: SymbolTable = None,
) -> PathResolvingEnvironmentPostSds:
with tempfile.TemporaryDirectory(prefix=program_info.PROGRAM_NAME +
'-test-sds-') as sds_root_dir:
sds = sds_module.construct_at(resolved_path_name(sds_root_dir))
environment = PathResolvingEnvironmentPostSds(
sds, symbol_table_from_none_or_value(symbols))
with preserved_cwd():
os.chdir(str(sds.act_dir))
pre_contents_population_action.apply(environment)
contents.populate_sds(sds)
yield environment
def __init__(self,
tcds: Optional[TcdsArrangement],
os_services: OsServices,
process_execution_settings: ProcessExecutionSettings,
default_environ_getter: DefaultEnvironGetter,
symbols: Optional[SymbolTable],
fs_location_info: FileSystemLocationInfo,
setup_settings: Optional[SetupSettingsArr],
):
self.tcds = tcds
self.os_services = os_services
self.process_execution_settings = process_execution_settings
self.setup_settings = setup_settings
self.symbols = symbol_table_from_none_or_value(symbols)
self.default_environ_getter = default_environ_getter
self.fs_location_info = fs_location_info
def __new__(
cls,
default_environ_getter: DefaultEnvironGetter,
environ: Optional[Mapping[str, str]],
timeout_in_seconds: Optional[int],
os_services: OsServices,
sandbox_root_dir_resolver: SandboxRootDirNameResolver,
mem_buff_size: int,
predefined_symbols: Optional[SymbolTable] = None,
exe_atc_and_skip_assertions: Optional[StdOutputFiles] = None,
):
return tuple.__new__(
cls, (environ, sandbox_root_dir_resolver,
symbol_table_from_none_or_value(predefined_symbols),
exe_atc_and_skip_assertions, os_services, mem_buff_size,
default_environ_getter, timeout_in_seconds))
def matches_string_matcher_resolver(primitive_value: ValueAssertion[StringMatcher] = asrt.anything_goes(),
references: ValueAssertion = asrt.is_empty_sequence,
symbols: symbol_table.SymbolTable = None,
tcds: HomeAndSds = fake_home_and_sds(),
) -> ValueAssertion[LogicValueResolver]:
symbols = symbol_table.symbol_table_from_none_or_value(symbols)
def resolve_value(resolver: LogicValueResolver):
return resolver.resolve(symbols)
def resolve_primitive_value(value: StringMatcherValue):
return value.value_of_any_dependency(tcds)
resolved_value_assertion = asrt.is_instance_with_many(
StringMatcherValue,
[
asrt.sub_component('resolving dependencies',
lambda sm_value: sm_value.resolving_dependencies(),
asrt.is_set_of(asrt.is_instance(DirectoryStructurePartition))),
asrt.sub_component('primitive value',
resolve_primitive_value,
asrt.is_instance_with(StringMatcher,
primitive_value))
])
return asrt.is_instance_with(
StringMatcherResolver,
asrt.and_([
is_resolver_of_logic_type(LogicValueType.STRING_MATCHER,
ValueType.STRING_MATCHER),
asrt.sub_component('references',
resolver_structure.get_references,
references),
asrt.sub_component('validator',
lambda resolver: resolver.validator,
asrt.is_instance(PreOrPostSdsValidator)
),
asrt.sub_component('resolved value',
resolve_value,
resolved_value_assertion
),
])
)
def __init__(self,
hds: HomeDs = fake_hds(),
sds: SandboxDs = fake_sds(),
environ: Optional[Dict[str, str]] = None,
timeout_in_seconds: int = None,
symbols: SymbolTable = None,
get_paths_access_for_dir:
Callable[[Path], DirFileSpace] = _default_get_tmp_space,
mem_buff_size: int = 2 ** 10,
):
self._hds = hds
self._sds = sds
self._environ = environ
self._timeout_in_seconds = timeout_in_seconds
self._symbols = symbol_table_from_none_or_value(symbols)
self._get_paths_access_for_dir = get_paths_access_for_dir
self.get_instr_tmp_file_space = lambda path: TmpFileStorage(path, get_paths_access_for_dir)
self.mem_buff_size = mem_buff_size
def tcds_with_act_as_curr_dir(
hds_contents: hds_populators.HdsPopulator = hds_populators.empty(),
sds_contents: sds_populator.SdsPopulator = sds_populator.empty(),
non_hds_contents: non_hds_populator.NonHdsPopulator = non_hds_populator.empty(),
tcds_contents: tcds_populators.TcdsPopulator = tcds_populators.empty(),
pre_contents_population_action: TcdsAction = TcdsAction(),
symbols: SymbolTable = None) -> ContextManager[PathResolvingEnvironmentPreOrPostSds]:
symbols = symbol_table_from_none_or_value(symbols)
prefix = strftime(program_info.PROGRAM_NAME + '-test-%Y-%m-%d-%H-%M-%S', localtime())
with home_directory_structure(prefix=prefix + '-home') as hds:
with sandbox_directory_structure(prefix=prefix + "-sds-") as sds:
tcds = TestCaseDs(hds, sds)
ret_val = PathResolvingEnvironmentPreOrPostSds(tcds, symbols)
with preserved_cwd():
os.chdir(str(sds.act_dir))
pre_contents_population_action.apply(ret_val)
hds_contents.populate_hds(hds)
sds_contents.populate_sds(sds)
non_hds_contents.populate_non_hds(sds)
tcds_contents.populate_tcds(tcds)
yield ret_val
def home_and_sds_with_act_as_curr_dir(
hds_contents: home_populators.HomePopulator = home_populators.empty(),
sds_contents: sds_populator.SdsPopulator = sds_populator.empty(),
non_home_contents: non_home_populator.NonHomePopulator = non_home_populator.empty(),
home_or_sds_contents: home_and_sds_populators.HomeOrSdsPopulator = home_and_sds_populators.empty(),
pre_contents_population_action: HomeAndSdsAction = HomeAndSdsAction(),
symbols: SymbolTable = None) -> PathResolvingEnvironmentPreOrPostSds:
symbols = symbol_table_from_none_or_value(symbols)
prefix = strftime(program_info.PROGRAM_NAME + '-test-%Y-%m-%d-%H-%M-%S', localtime())
with home_directory_structure(prefix=prefix + '-home') as hds:
with sandbox_directory_structure(prefix=prefix + "-sds-") as sds:
home_and_sds = HomeAndSds(hds, sds)
ret_val = PathResolvingEnvironmentPreOrPostSds(home_and_sds, symbols)
with preserved_cwd():
os.chdir(str(sds.act_dir))
pre_contents_population_action.apply(ret_val)
hds_contents.populate_hds(hds)
sds_contents.populate_sds(sds)
non_home_contents.populate_non_home(sds)
home_or_sds_contents.populate_home_or_sds(home_and_sds)
yield ret_val
def matches_resolver_of_logic_type(resolver_type: type,
logic_value_type: LogicValueType,
value_type: ValueType,
resolved_value: ValueAssertion = asrt.anything_goes(),
references: ValueAssertion[Sequence[SymbolReference]] = asrt.is_empty_sequence,
symbols: symbol_table.SymbolTable = None) -> ValueAssertion[Any]:
symbols = symbol_table.symbol_table_from_none_or_value(symbols)
def resolve_value(resolver: LogicValueResolver) -> LineMatcher:
return resolver.resolve(symbols)
return asrt.is_instance_with(resolver_type,
asrt.and_([
is_resolver_of_logic_type(logic_value_type,
value_type),
asrt.on_transformed(resolve_value,
resolved_value),
asrt.sub_component('references',
resolver_structure.get_references,
references),
]))
def __init__(self,
pre_contents_population_action: HomeAndSdsAction = HomeAndSdsAction(),
hds_contents: home_populators.HomePopulator = home_populators.empty(),
sds_contents: sds_populator.SdsPopulator = sds_populator.empty(),
non_home_contents: non_home_populator.NonHomePopulator = non_home_populator.empty(),
home_or_sds_contents: home_and_sds_populators.HomeOrSdsPopulator = home_and_sds_populators.empty(),
os_services: OsServices = new_default(),
process_execution_settings=with_no_timeout(),
post_sds_population_action: HomeAndSdsAction = HomeAndSdsAction(),
symbols: SymbolTable = None,
fs_location_info: FileSystemLocationInfo = ARBITRARY_FS_LOCATION_INFO,
):
super().__init__(hds_contents=hds_contents,
process_execution_settings=process_execution_settings)
self.pre_contents_population_action = pre_contents_population_action
self.sds_contents = sds_contents
self.non_home_contents = non_home_contents
self.home_or_sds_contents = home_or_sds_contents
self.post_sds_population_action = post_sds_population_action
self.os_services = os_services
self.process_execution_settings = process_execution_settings
self.symbols = symbol_table_from_none_or_value(symbols)
self.fs_location_info = fs_location_info
def test_symbol_table_from_none_or_value_SHOULD_give_empty_table_WHEN_argument_is_none(self):
actual = sut.symbol_table_from_none_or_value(None)
self.assertFalse(actual.names_set,
'names set should be empty')
def __init__(self,
tcds_populator: TcdsPopulator,
symbols: SymbolTable = None):
self.tcds_populator = tcds_populator
self.symbols = symbol_table_from_none_or_value(symbols)
def test_symbol_table_from_none_or_value_SHOULD_give_empty_table_WHEN_argument_is_none(self):
actual = sut.symbol_table_from_none_or_value(None)
self.assertFalse(actual.names_set,
'names set should be empty')
def __init__(self, builtin_symbols: Optional[SymbolTable]):
self._builtin_symbols = symbol_table.symbol_table_from_none_or_value(
builtin_symbols)
def __init__(self, symbols: Optional[SymbolTable] = None):
self.symbols = symbol_table_from_none_or_value(symbols)
