def test_superfluous_arguments(self):
# ARRANGE #
arbitrary_transformer_symbol = StringTransformerSymbolContext.of_arbitrary_value(
'TRANSFORMER_SYMBOL')
src_file_relativity_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
file_contents_builder = string_source_abs_stx.TransformableAbsStxBuilder(
string_source_abs_stx.StringSourceOfFileAbsStx(
src_file_relativity_conf.path_abs_stx_of_name('src-file.txt')))
file_contents_cases = [
NameAndValue('contents of existing file / without transformation',
file_contents_builder.without_transformation()),
NameAndValue(
'contents of existing file / with transformation',
file_contents_builder.with_transformation(
arbitrary_transformer_symbol.abstract_syntax)),
]
for file_contents_case in file_contents_cases:
valid_instruction_syntax = instr_abs_stx.create_w_explicit_contents(
path_abs_stx.DefaultRelPathAbsStx('dst-file.txt'),
file_contents_case.value,
)
invalid_instruction_syntax = custom_abs_stx.SequenceAbsStx([
valid_instruction_syntax,
custom_abs_stx.CustomAbstractSyntax.singleton(
'superfluous_argument')
])
with self.subTest(file_contents_variant=file_contents_case.name):
# ACT & ASSERT #
check_invalid_syntax__abs_stx(self, invalid_instruction_syntax)
def _file_contents_cases(self) -> InvalidDestinationFileTestCasesData:
arbitrary_transformer = StringTransformerSymbolContext.of_primitive(
'TRANSFORMER_SYMBOL',
string_transformers.to_uppercase(),
)
symbols = arbitrary_transformer.symbol_table
relativity_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
src_file = relativity_conf.path_abs_stx_of_name('src-file.txt')
contents_abs_stx_builder = string_source_abs_stx.TransformableAbsStxBuilder(
string_source_abs_stx.StringSourceOfFileAbsStx(src_file))
src_file_in_hds_contents = relativity_conf.populator_for_relativity_option_root(
DirContents([File.empty(src_file.name)]))
file_contents_cases = [
NameAndValue(
'contents of existing file / without transformation',
fs_abs_stx.FileContentsExplicitAbsStx(
fs_abs_stx.ModificationType.CREATE,
contents_abs_stx_builder.without_transformation())),
NameAndValue(
'contents of existing file / with transformation',
fs_abs_stx.FileContentsExplicitAbsStx(
fs_abs_stx.ModificationType.CREATE,
contents_abs_stx_builder.with_transformation(
arbitrary_transformer.abstract_syntax))),
]
return InvalidDestinationFileTestCasesData(file_contents_cases,
symbols,
src_file_in_hds_contents)
def test_with_reference_to_existing_file(self):
referenced_file = 'referenced-file.txt'
relativity_cases = [
relativity_options.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE),
relativity_options.conf_rel_non_hds(RelNonHdsOptionType.REL_ACT),
]
for file_existence_case in FILE_EXISTENCE_CASES:
for relativity_conf in relativity_cases:
source_syntax = RawSystemCommandLineAbsStx.of_str(
'program_name', [
ArgumentOfExistingPathAbsStx(
relativity_conf.path_abs_stx_of_name(
referenced_file))
])
with self.subTest(
relativity=relativity_conf.option_string,
file_do_existence_case=file_existence_case.name):
# 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,
source_syntax,
arrangement_w_tcds(
tcds_contents=relativity_conf.
populator_for_relativity_option_root(
DirContents(
file_existence_case.files_for_name(
referenced_file)))),
MultiSourceExpectation(execution=ExecutionExpectation(
validation=file_existence_case.expectation_for(
relativity_conf.directory_structure_partition))
),
)
def runTest(self):
# ARRANGE #
src_file = fs.File('source-file.txt', 'contents of source file')
src_rel_opt_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
expected_file = fs.File('a-file-name.txt', src_file.contents.upper())
dst_rel_opt_conf = conf_rel_non_hds(RelNonHdsOptionType.REL_ACT)
to_upper_transformer = StringTransformerSymbolContext.of_primitive(
'TRANSFORMER_SYMBOL',
to_uppercase(),
)
symbols = to_upper_transformer.symbol_table
transformed_file_syntax = string_source_abs_stx.TransformedStringSourceAbsStx(
string_source_abs_stx.StringSourceOfFileAbsStx(
src_rel_opt_conf.path_abs_stx_of_name(src_file.name)),
to_upper_transformer.abstract_syntax,
)
instruction_syntax = instr_abs_stx.create_w_explicit_contents(
dst_rel_opt_conf.path_abs_stx_of_name(expected_file.name),
transformed_file_syntax,
)
expected_non_hds_contents = dst_rel_opt_conf.assert_root_dir_contains_exactly(
fs.DirContents([expected_file]))
instruction_checker = self.conf.instruction_checker
parser = self.conf.parser()
for source_case in equivalent_source_variants__with_source_check__consume_last_line__abs_stx(
instruction_syntax):
with self.subTest(source_case.name):
source = source_case.value.source
# ACT #
instruction = parser.parse(ARBITRARY_FS_LOCATION_INFO, source)
# ASSERT #
source_case.value.expectation.apply_with_message(
self, source, 'source-after-parse')
# ACT & ASSERT #
instruction_checker.check(
self, instruction,
self.conf.arrangement(
pre_contents_population_action=
SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR,
tcds_contents=src_rel_opt_conf.
populator_for_relativity_option_root(
DirContents([src_file])),
symbols=symbols,
),
self.conf.expect_success(
symbol_usages=asrt.matches_sequence([
to_upper_transformer.reference_assertion,
]),
main_side_effects_on_sds=expected_non_hds_contents,
))
def runTest(self):
# ARRANGE #
to_upper_transformer = StringTransformerSymbolContext.of_primitive(
'TRANSFORMER_SYMBOL',
string_transformers.to_uppercase(),
)
src_file = fs.File('src-file.txt', 'contents of source file')
src_file_rel_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
expected_contents = src_file.contents.upper()
path_relativity_variants = PathRelativityVariants({src_file_rel_conf.relativity}, True)
checker = integration_check.checker(RelOptionsConfiguration(path_relativity_variants,
src_file_rel_conf.relativity))
src_file_symbol = ConstantSuffixPathDdvSymbolContext(
'SRC_FILE_SYMBOL',
src_file_rel_conf.relativity,
src_file.name,
path_relativity_variants,
)
string_source_syntax = string_source_abs_stx.TransformedStringSourceAbsStx(
string_source_abs_stx.StringSourceOfFileAbsStx(src_file_symbol.abstract_syntax),
to_upper_transformer.abstract_syntax,
)
symbol_table = SymbolContext.symbol_table_of_contexts([
src_file_symbol,
to_upper_transformer,
])
# ACT & ASSERT #
checker.check__abs_stx__layouts__std_source_variants__wo_input(
self,
OptionallyOnNewLine(string_source_syntax),
arrangement_w_tcds(
symbols=symbol_table,
hds_contents=src_file_rel_conf.populator_for_relativity_option_root__hds(
DirContents([src_file]))
),
MultiSourceExpectation.of_prim__const(
asrt_string_source.pre_post_freeze__matches_str__const(
expected_contents,
may_depend_on_external_resources=True,
),
symbol_references=asrt.matches_sequence([
src_file_symbol.reference_assertion__path_or_string,
to_upper_transformer.reference_assertion,
]),
),
)
def cases__w_argument_list__excluding_program_reference() -> List[PgmAndArgsCase]:
"""Cases of pgm-and-arg:s that have a list of arguments."""
executable_file = fs.executable_file('executable-file', '')
exe_file_relativity = rel_opt.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
executable_file_ddv = path_ddvs.of_rel_option(exe_file_relativity.relativity,
path_ddvs.constant_path_part(executable_file.name)
)
system_program = 'the-system-program'
return [
PgmAndArgsCase.w_tcds(
'executable file',
pgm_and_args=pgm_abs_stx.ProgramOfExecutableFileCommandLineAbsStx(
exe_file_relativity.named_file_conf(executable_file.name).abstract_syntax
),
expected_command_driver=lambda env: (
asrt_command.matches_executable_file_command_driver(
asrt.equals(executable_file_ddv.value_of_any_dependency__d(env.tcds).primitive),
)),
tcds=exe_file_relativity.populator_for_relativity_option_root__hds(
DirContents([executable_file])
)
),
PgmAndArgsCase.wo_tcds(
'-python',
pgm_and_args=pgm_abs_stx.ProgramOfPythonInterpreterAbsStx(()),
expected_command_driver=prim_asrt__constant(
asrt_command.matches_executable_file_command_driver(
asrt_path.path_as_str(asrt.equals(sys.executable)),
)),
),
PgmAndArgsCase.wo_tcds(
'system program',
pgm_and_args=pgm_abs_stx.ProgramOfSystemCommandLineAbsStx(
StringLiteralAbsStx(system_program)
),
expected_command_driver=prim_asrt__constant(
asrt_command.matches_system_program_command_driver(
asrt.equals(system_program)
))
),
]
def _single_line_command_cases() -> List[Case]:
exe_file_name = 'executable-file'
exe_file_relativity__explicit = rel_opt.conf_rel_hds(
RelHdsOptionType.REL_HDS_ACT)
exe_file_ddv__explicit_relativity = path_ddvs.of_rel_option(
exe_file_relativity__explicit.relativity,
path_ddvs.constant_path_part(exe_file_name))
exe_file_relativity__default = rel_opt.default_conf_rel_hds(
RelHdsOptionType.REL_HDS_CASE)
exe_file_ddv__default_relativity = path_ddvs.of_rel_option(
exe_file_relativity__default.relativity,
path_ddvs.constant_path_part(exe_file_name))
system_program = 'the-system-program'
system_program_symbol = StringConstantSymbolContext(
'SYSTEM_PROGRAM_SYMBOL',
system_program,
default_restrictions=reference_assertions.
IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS,
)
return [
Case(
'executable file / explicit relativity',
source=pgm_args.executable_file_command_line(
exe_file_relativity__explicit.named_file_conf(
exe_file_name).cl_argument.as_str),
expected_command_driver=lambda tcds:
(asrt_command.matches_executable_file_command_driver(
asrt.equals(
exe_file_ddv__explicit_relativity.
value_of_any_dependency__d(tcds).primitive), )),
),
Case(
'executable file / default relativity',
source=pgm_args.executable_file_command_line(
exe_file_relativity__default.named_file_conf(
exe_file_name).cl_argument.as_str),
expected_command_driver=lambda tcds:
(asrt_command.matches_executable_file_command_driver(
asrt.equals(
exe_file_ddv__default_relativity.
value_of_any_dependency__d(tcds).primitive), )),
),
Case(
'-python',
source=pgm_args.py_interpreter_command_line(),
expected_command_driver=constant_assertion(
asrt_command.matches_executable_file_command_driver(
asrt_path.path_as_str(asrt.equals(sys.executable)), )),
),
Case('system program',
source=pgm_args.system_program_command_line(system_program),
expected_command_driver=constant_assertion(
asrt_command.matches_system_program_command_driver(
asrt.equals(system_program)))),
Case('system program / w symbol reference',
source=pgm_args.system_program_command_line(
system_program_symbol.name__sym_ref_syntax),
symbols=[system_program_symbol],
expected_command_driver=constant_assertion(
asrt_command.matches_system_program_command_driver(
asrt.equals(system_program_symbol.str_value)))),
]
EXPECTED_ACCEPTED_PATH_RELATIVITY_VARIANTS = PathRelativityVariants(
{RelOptionType.REL_CWD,
RelOptionType.REL_HDS_CASE,
RelOptionType.REL_HDS_ACT,
RelOptionType.REL_ACT,
RelOptionType.REL_TMP},
True)
ACCEPTED_REL_OPT_CONFIGURATIONS = (
list(map(rel_opt_conf.conf_rel_any, EXPECTED_ACCEPTED_PATH_RELATIVITY_VARIANTS.rel_option_types)) +
[rel_opt_conf.symbol_conf_rel_any(RelOptionType.REL_TMP,
'symbol_name',
EXPECTED_ACCEPTED_PATH_RELATIVITY_VARIANTS)] +
[rel_opt_conf.default_conf_rel_any(RelOptionType.REL_CWD)]
)
UNACCEPTED_REL_OPT_CONFIGURATIONS = [
rel_opt_conf.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE),
rel_opt_conf.conf_rel_sds(RelSdsOptionType.REL_RESULT),
]
MAKE_CWD_OUTSIDE_OF_EVERY_REL_OPT_DIR = TcdsActionFromPlainTcdsAction(
MkSubDirAndMakeItCurrentDirectory(
SdsSubDirResolverFromSdsFun(lambda sds: sds.root_dir / 'test-cwd')
)
)
if __name__ == '__main__':
unittest.TextTestRunner().run(suite())
def test_symbol_usages(self):
# ARRANGE #
to_upper_transformer = StringTransformerSymbolContext.of_primitive(
'TRANSFORMER_SYMBOL',
string_transformers.to_uppercase(),
)
src_file = fs.File('src-file.txt', 'contents of source file')
src_file_rel_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
expected_dst_file = fs.File('dst-file-name.txt',
src_file.contents.upper())
dst_file_symbol = ConstantSuffixPathDdvSymbolContext(
'DST_FILE_SYMBOL',
RelOptionType.REL_TMP,
expected_dst_file.name,
sut.REL_OPT_ARG_CONF.options.accepted_relativity_variants,
)
for phase_is_after_act in [False, True]:
checker = integration_check.checker(phase_is_after_act)
src_file_rel_opt_conf = src_rel_opt_arg_conf_for_phase(
phase_is_after_act)
src_file_symbol = ConstantSuffixPathDdvSymbolContext(
'SRC_FILE_SYMBOL',
src_file_rel_conf.relativity_option,
src_file.name,
src_file_rel_opt_conf.options.accepted_relativity_variants,
)
transformed_file_contents = string_source_abs_stx.TransformedStringSourceAbsStx(
string_source_abs_stx.StringSourceOfFileAbsStx(
src_file_symbol.abstract_syntax),
StringTransformerSymbolReferenceAbsStx(
to_upper_transformer.name))
instruction_syntax = instr_abs_stx.create_w_explicit_contents(
dst_file_symbol.abstract_syntax,
transformed_file_contents,
)
symbols = SymbolContext.symbol_table_of_contexts([
dst_file_symbol,
src_file_symbol,
to_upper_transformer,
])
with self.subTest(phase_is_after_act=phase_is_after_act):
# ACT & ASSERT #
checker.check__abs_stx__std_layouts_and_source_variants(
self,
instruction_syntax,
Arrangement.phase_agnostic(
symbols=symbols,
tcds=TcdsArrangement(
hds_contents=src_file_rel_conf.
populator_for_relativity_option_root__hds(
DirContents([src_file]))),
),
MultiSourceExpectation.phase_agnostic(
main_result=IS_SUCCESS,
symbol_usages=asrt.matches_sequence([
dst_file_symbol.
reference_assertion__path_or_string,
src_file_symbol.
reference_assertion__path_or_string,
is_reference_to_string_transformer__usage(
to_upper_transformer.name),
]),
),
)
def runTest(self):
# ARRANGE #
actor = sut.actor(COMMAND_THAT_RUNS_PYTHON_PROGRAM_FILE)
exe_file = fs.python_executable_file(
'program-name',
py_programs.exit_with_0()
)
text_until_end_of_line = 'some {}invalidly quoted text'.format(SOFT_QUOTE_CHAR)
existing_path_relativity = relativity_options.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
existing_path_argument = path_arguments.RelOptPathArgument(
'existing-path',
existing_path_relativity.relativity,
)
act_contents = ab.sequence__r([
ab.singleton(exe_file.name),
program_arguments.existing_path(
existing_path_argument
),
program_arguments.remaining_part_of_current_line_as_literal(text_until_end_of_line),
])
def get_command_assertion(tcds: TestCaseDs) -> Assertion[Command]:
symbols = SymbolTable.empty()
return asrt_command.matches_command(
asrt.anything_goes(),
asrt.equals([
str(relativity_configurations.ATC_FILE
.named_file_conf(exe_file.name)
.path_sdv
.resolve(symbols)
.value_of_any_dependency__d(tcds)
.primitive
),
str(existing_path_relativity
.named_file_conf(existing_path_argument.name)
.path_sdv
.resolve(symbols)
.value_of_any_dependency__d(tcds)
.primitive
),
text_until_end_of_line,
])
)
act_instruction = instr([act_contents.as_str])
executor_that_records_arguments = CommandExecutorThatRecordsArguments()
# ACT & ASSERT #
integration_check.check_execution(
self,
actor,
[act_instruction],
arrangement_w_tcds(
process_execution=ProcessExecutionArrangement(
os_services=os_services_access.new_for_cmd_exe(executor_that_records_arguments)
),
hds_contents=hds_populators.multiple([
relativity_configurations.ATC_FILE.populator_for_relativity_option_root__hds(
fs.DirContents([exe_file])
),
existing_path_relativity.populator_for_relativity_option_root__hds(
fs.DirContents([fs.File.empty(existing_path_argument.name)])
),
])
),
Expectation(
after_execution=ExecutedCommandAssertion(
executor_that_records_arguments,
get_command_assertion,
)
),
)
from exactly_lib.tcfs.path_relativity import RelHdsOptionType
from exactly_lib_test.impls.types.test_resources import relativity_options
PROGRAM_FILE = relativity_options.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
INTERPRETER_FILE = relativity_options.conf_rel_hds(
RelHdsOptionType.REL_HDS_CASE)
ATC_FILE = relativity_options.conf_rel_hds(RelHdsOptionType.REL_HDS_ACT)
from exactly_lib.tcfs.path_relativity import RelOptionType, PathRelativityVariants, DEPENDENCY_DICT, \
DirectoryStructurePartition, RelHdsOptionType, RelNonHdsOptionType
from exactly_lib_test.impls.types.test_resources import relativity_options as rel_opt_conf
def path_relativity_variants__src(
phase_is_after_act: bool) -> PathRelativityVariants:
rel_opts = set(RelOptionType)
if not phase_is_after_act:
rel_opts.remove(RelOptionType.REL_RESULT)
return PathRelativityVariants(rel_opts, True)
PATH_RELATIVITY_VARIANTS__DST = PathRelativityVariants(
DEPENDENCY_DICT[DirectoryStructurePartition.NON_HDS] -
{RelOptionType.REL_RESULT},
False,
)
ARBITRARY_LEGAL_RELATIVITY__SRC = RelOptionType.REL_HDS_CASE
ARBITRARY_LEGAL_RELATIVITY__SRC__HDS = RelHdsOptionType.REL_HDS_CASE
ARBITRARY_LEGAL_RELATIVITY__DST = RelOptionType.REL_ACT
ARBITRARY_LEGAL_RELATIVITY__DST__NON_HDS = RelNonHdsOptionType.REL_ACT
ARBITRARY_SRC_REL_OPT = rel_opt_conf.conf_rel_hds(RelHdsOptionType.REL_HDS_ACT)
ARBITRARY_DST_REL_OPT = rel_opt_conf.conf_rel_non_hds(
RelNonHdsOptionType.REL_ACT)
DEFAULT_SRC_REL_OPT = rel_opt_conf.default_conf_rel_hds(
RelHdsOptionType.REL_HDS_CASE)
DEFAULT_DST_REL_OPT = rel_opt_conf.default_conf_rel_non_hds(
RelNonHdsOptionType.REL_CWD)
from typing import Sequence, Set
from exactly_lib.tcfs.path_relativity import RelHdsOptionType, RelSdsOptionType, RelNonHdsOptionType, RelOptionType, \
PathRelativityVariants
from exactly_lib_test.impls.types.test_resources.relativity_options import conf_rel_hds, conf_rel_sds, conf_rel_non_hds, \
default_conf_rel_non_hds, RelativityOptionConfiguration, default_conf_rel_hds
ALLOWED_SRC_FILE_RELATIVITIES__BEFORE_ACT = [
conf_rel_hds(RelHdsOptionType.REL_HDS_CASE),
conf_rel_hds(RelHdsOptionType.REL_HDS_ACT),
conf_rel_sds(RelSdsOptionType.REL_ACT),
conf_rel_sds(RelSdsOptionType.REL_TMP),
conf_rel_non_hds(RelNonHdsOptionType.REL_CWD),
default_conf_rel_hds(RelHdsOptionType.REL_HDS_CASE),
]
DISALLOWED_DST_RELATIVITIES = [
RelOptionType.REL_RESULT,
RelOptionType.REL_HDS_CASE,
RelOptionType.REL_HDS_ACT,
]
ARBITRARY_ALLOWED_SRC_FILE_RELATIVITY = conf_rel_non_hds(
RelNonHdsOptionType.REL_TMP)
ARBITRARY_ALLOWED_DST_FILE_RELATIVITY = conf_rel_non_hds(
RelNonHdsOptionType.REL_TMP)
ALLOWED_DST_FILE_RELATIVITIES = [
conf_rel_non_hds(RelNonHdsOptionType.REL_ACT),
conf_rel_non_hds(RelNonHdsOptionType.REL_TMP),
conf_rel_non_hds(RelNonHdsOptionType.REL_CWD),
def source_relativity_options__hds() -> List[RelativityOptionConfigurationRelHds]:
return [
rel_opt_conf.default_conf_rel_hds(RelHdsOptionType.REL_HDS_CASE),
rel_opt_conf.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE),
rel_opt_conf.conf_rel_hds(RelHdsOptionType.REL_HDS_ACT),
]
