def test_copy_file__non_existing_destination(self):
dst_file_name = 'dst-file_name-file.txt'
sub_dir_name = 'src-sub-dir'
source_file_contents = 'contents'
src_file = File('src-file_name-file.txt', source_file_contents)
home_dir_contents_cases = [
(src_file.file_name, DirContents([src_file])),
(str(PurePosixPath(sub_dir_name) / src_file.file_name),
DirContents([Dir(sub_dir_name, [src_file])
])),
]
expected_destination_dir_contents = DirContents([File(dst_file_name, src_file.contents)])
for src_rel_option in source_relativity_options__hds():
for dst_rel_option in destination_relativity_options():
for src_argument, home_dir_contents in home_dir_contents_cases:
self._sub_test__copy_file(
src_rel_option=src_rel_option,
dst_rel_option=dst_rel_option,
src_file_name=src_argument,
dst_file_name=dst_file_name,
hds_contents=src_rel_option.populator_for_relativity_option_root__hds(home_dir_contents),
sds_populator_before_main=sds_populator.empty(),
expected_destination_dir_contents=expected_destination_dir_contents,
)
def test_file_is_directory_with_files_but_none_that_matches_name_pattern(
self):
name_of_directory = 'name-of-directory'
pattern_that_matches_exactly_one_file = 'a*'
dir_with_two_files = Dir(name_of_directory, [
File.empty('a file'),
File.empty('b file'),
])
contents_of_relativity_option_root = DirContents([dir_with_two_files])
instruction_argument_constructor = argument_constructor_for_num_files_check(
int_condition(comparators.EQ, 1),
name_option_pattern=pattern_that_matches_exactly_one_file)
self.checker.check_parsing_with_different_source_variants(
instruction_argument_constructor,
model.model_with_source_path_as_sub_dir_of_rel_root(
name_of_directory),
default_relativity=RelOptionType.REL_CWD,
non_default_relativity=RelOptionType.REL_TMP,
main_result_for_positive_expectation=PassOrFail.PASS,
contents_of_relativity_option_root=
contents_of_relativity_option_root,
)
def test_symlink(self):
link_target = 'link-target-file'
file_to_check = 'file-to-check'
cases = [
NEA('match: symlink to regular',
True,
DirContents([File.empty(link_target),
sym_link(file_to_check, link_target)]),
),
NEA('match: symlink to directory',
True,
DirContents([Dir.empty(link_target),
sym_link(file_to_check, link_target)]),
),
NEA('match: broken symlink',
True,
DirContents([sym_link(file_to_check, 'non-existing-target-file')]),
),
NEA('not match: actual is regular',
False,
DirContents([File.empty(file_to_check)]),
),
]
for case in cases:
with self.subTest(case_name=case.name):
self._check(file_type_to_check_for=FileType.SYMLINK,
expected_result=case.expected,
base_name_of_file_to_check=file_to_check,
dir_contents=case.actual)
def test_directory(self):
dir_to_check = 'dir-to-check'
cases = [
NEA('match',
True,
DirContents([Dir.empty(dir_to_check)]),
),
NEA('match: symlink to directory',
True,
DirContents([Dir.empty('the dir'),
sym_link(dir_to_check, 'the dir')]),
),
NEA('not match: actual is regular',
False,
DirContents([File.empty(dir_to_check)]),
),
NEA('not match: actual is broken symlink',
False,
DirContents([File.empty('the file.txt'),
sym_link(dir_to_check, 'name-of-non-existing-file')]),
),
]
for case in cases:
with self.subTest(case_name=case.name):
self._check(file_type_to_check_for=FileType.DIRECTORY,
expected_result=case.expected,
base_name_of_file_to_check=dir_to_check,
dir_contents=case.actual)
def _phase_instructions_in_suite_not_containing_cases(self):
# ARRANGE #
files = Files(self._phase_config())
containing_suite_file = File(
'sub.suite', files.suite_with_phase_instruction_and_cases)
non_containing_suite_file = File(
'main.suite',
files.suite_with_phase_instruction_but_with_just_a_suite(
containing_suite_file.file_name))
suite_and_case_files = DirContents([
non_containing_suite_file,
containing_suite_file,
files.file_1_with_registering_instruction,
files.file_2_with_registering_instruction,
])
expectation = self._expected_recordings_assertion(
containing_suite_file.name,
files.file_1_with_registering_instruction.name,
files.file_2_with_registering_instruction.name,
)
# ACT & ASSERT #
self._check(containing_suite_file, suite_and_case_files, expectation)
def file_structure(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File('main.suite', lines_content(['[suites]', '?'])),
File.empty('1'),
Dir('2', []),
File.empty('3'),
])
def __init__(self, phase_config: PhaseConfig):
self.phase_config = phase_config
self.file_1_with_registering_instruction = File(
'1.case',
CASE_THAT_REGISTERS_MARKER.format(
case_phase_header=self.phase_config.phase_name().syntax,
phase_contents_line_that_records=self.phase_config.
phase_contents_line_that_registers(
INSTRUCTION_MARKER_IN_CASE_1)))
self.file_2_with_registering_instruction = File(
'2.case',
CASE_THAT_REGISTERS_MARKER.format(
case_phase_header=self.phase_config.phase_name().syntax,
phase_contents_line_that_records=self.phase_config.
phase_contents_line_that_registers(
INSTRUCTION_MARKER_IN_CASE_2)))
self.suite_with_phase_instruction_and_cases = SUITE_WITH_PHASE_INSTRUCTION_AND_CASES.format(
case_phase_header=self.phase_config.phase_name().syntax,
phase_contents_line_that_records=self.phase_config.
phase_contents_line_that_registers(
INSTRUCTION_MARKER_IN_CONTAINING_SUITE),
case_1_file=self.file_1_with_registering_instruction.file_name,
case_2_file=self.file_2_with_registering_instruction.file_name,
)
def test_destination_already_exists_in_destination_directory(self):
src = 'src-file-name'
dst = 'dst-dir-name'
home_dir_contents = DirContents([(File.empty(src))])
cwd_dir_contents = DirContents([Dir(dst,
[File.empty(src)])])
for parser_case in _EXECUTION_CHECKERS:
with self.subTest(parser=parser_case.name):
# ACT & ASSERT #
parser_case.value.check(
self,
args.copy(
defs.DEFAULT_SRC_REL_OPT.path_argument_of_rel_name(src),
defs.DEFAULT_DST_REL_OPT.path_argument_of_rel_name(dst)
).as_remaining_source,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(
pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY,
hds_contents=defs.DEFAULT_SRC_REL_OPT.populator_for_relativity_option_root__hds(
home_dir_contents),
sds_contents=defs.DEFAULT_DST_REL_OPT.populator_for_relativity_option_root__sds(
cwd_dir_contents
),
)
),
Expectation.phase_agnostic(
main_result=asrt_text_doc.is_any_text(),
),
)
def test_destination_already_exists__without_explicit_destination(self):
# ARRANGE #
file_name = 'existing-file'
file_to_install = DirContents([(File(file_name,
'contents'))])
for parser_case in _EXECUTION_CHECKERS:
with self.subTest(parser=parser_case.name):
# ACT & ASSERT #
parser_case.value.check(
self,
args.copy(
defs.DEFAULT_SRC_REL_OPT.path_argument_of_rel_name(file_name)
).as_remaining_source,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(
pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY,
hds_contents=defs.DEFAULT_SRC_REL_OPT.populator_for_relativity_option_root__hds(
file_to_install),
sds_contents=defs.DEFAULT_DST_REL_OPT.populator_for_relativity_option_root__sds(
DirContents([File.empty(file_name)])
),
)
),
Expectation.phase_agnostic_2(
main_result=asrt_text_doc.is_any_text(),
)
)
class SelectorShouldBeApplied(MultipleExecutionCasesGenerator):
min_depth = 1
max_depth = 1
num_regular_files_eq_1 = [
Dir('lvl0', [
File.empty('lvl1-included'),
Dir('lvl1-not-included', [
File.empty('lvl2-not-included-file'),
Dir.empty('lvl2-not-included-dir'),
])
])
]
num_regular_files_eq_2 = [
Dir('lvl0', [
File.empty('lvl1-included-1'),
File.empty('lvl1-included-2'),
Dir('lvl1-not-included', [
File.empty('lvl2-not-included-file'),
Dir.empty('lvl2-not-included-dir'),
])
])
]
num_files_setup = NumFilesSetup(comparators.EQ, 2, [
NEA(
'not match',
False,
num_regular_files_eq_1,
),
NEA(
'match',
True,
num_regular_files_eq_2,
),
])
def arguments(self) -> FileMatcherArg:
return _as_arguments(
RecWLimArguments(
fms_args.Selection(fm_args.Type(FileType.REGULAR),
self.num_files_setup.num_files_arg()),
self.min_depth,
self.max_depth,
))
def expected_symbols(self) -> Sequence[Assertion[SymbolReference]]:
return ()
def execution_cases(
self) -> Sequence[NExArr[ExecutionResult, Arrangement]]:
return [
NExArr(
num_files_setup.name,
FullExecutionResult(num_files_setup.expected),
Arrangement(tcds=self._helper.
tcds_arrangement_for_contents_of_checked_dir(
num_files_setup.actual)))
for num_files_setup in self.num_files_setup.cases
]
def test_copy_directory(self):
src_path_arg = defs.DEFAULT_SRC_REL_OPT.path_argument_of_rel_name('existing-dir')
files_to_install = DirContents([Dir(src_path_arg.name,
[File('a', 'a'),
Dir('d', []),
Dir('d2',
[File('f', 'f')])
])])
for execution_checker in _EXECUTION_CHECKERS:
with self.subTest(parser=execution_checker.name):
execution_checker.value.check(
self,
args.copy(src_path_arg).as_remaining_source,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(
pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY,
hds_contents=defs.DEFAULT_SRC_REL_OPT.populator_for_relativity_option_root__hds(
files_to_install),
),
),
Expectation.phase_agnostic_2(
main_side_effects_on_sds=sds_contents_check.cwd_contains_exactly(
files_to_install)
)
)
def file_structure(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File('main.suite', lines_content(['[cases]', '_[!a-bx].case'])),
File.empty('_b.case'),
File.empty('_x.case'),
File.empty('_a.case'),
File.empty('_c.case'),
])
def test_all_files_in_dir_WHEN_argument_is_glob_including_all_files(self):
file_1 = File.empty('1-file.ext')
file_2 = File.empty('2-file.ext')
self._expect_success(contents_dir_contents=DirContents(
[file_1, file_2]),
source='*',
expected_contents_rel_contents_dir=[
file_1.name_as_path,
file_2.name_as_path,
])
def _run(self, test_case_runner: TestCaseRunner, suite_file_name: str,
suite_file_overriding: Optional[Path]):
# ARRANGE #
expected_instruction_recording = [
# First test case
SETUP_INSTRUCTION_IN_CONTAINING_SUITE,
SETUP_INSTRUCTION_IN_CASE,
]
suite_file = File(
suite_file_name,
SUITE_WITH_SETUP_INSTRUCTION.format(
marker=SETUP_INSTRUCTION_IN_CONTAINING_SUITE))
case_file = File(
'test.case',
CASE_THAT_REGISTERS_MARKER.format(
marker=SETUP_INSTRUCTION_IN_CASE))
sub_dir_path = Path('dir-containing-test-case')
suite_and_case_files = DirContents([
suite_file,
case_file,
])
explicit_suite_file_path = None
if suite_file_overriding:
explicit_suite_file_path = sub_dir_path / suite_file_overriding
recording_media = []
test_case_parsing_setup = TestCaseParsingSetup(
space_separator_instruction_name_extractor,
instruction_setup_with_setup_instructions(
REGISTER_INSTRUCTION_NAME, recording_media), ActPhaseParser())
test_case_handling_setup = test_case_handling_setup_with_identity_preprocessor(
)
test_suite_definition = test_suite_definition_without_instructions()
# ACT #
with tmp_dir_as_cwd(suite_and_case_files.in_dir_path(sub_dir_path)):
actual_result = test_case_runner.run(
test_case_parsing_setup, test_case_handling_setup,
test_suite_definition, sub_dir_path / case_file.name_as_path,
explicit_suite_file_path)
# ASSERT #
self.assertEqual(exit_values.EXECUTION__PASS.exit_code,
actual_result.exitcode,
'Sanity check of result indicator')
recordings = list(map(Recording.string.fget, recording_media))
self.assertEqual(expected_instruction_recording, recordings)
def file_structure_to_read(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File(
'main.suite',
lines_content([
section_names.CASES.syntax,
'case-with-invalid-content.case',
])),
File('case-with-invalid-content.case',
'invalid content in test case'),
])
def assert_dir_contains_exactly_result_files(expected: SubProcessResult,
file_names: FileNames = process_output_files.FILE_NAMES
) -> Assertion:
return fa.dir_contains_exactly(DirContents([
File(file_names.exit_code,
str(expected.exitcode)),
File(file_names.stdout,
expected.stdout),
File(file_names.stderr,
expected.stderr),
]))
class ReferencedInclusionDirectiveFileInIncludedFileDoesNotExist(
check_exception.Setup):
file_1_invalid_inclusion_line = ' '.join(
[INCLUDING_DIRECTIVE_INFO.singular_name, 'does-not-exist.txt'])
file_1 = File('1.xly', lines_content([file_1_invalid_inclusion_line]))
root_suite_inclusion_line = ' '.join(
[INCLUDING_DIRECTIVE_INFO.singular_name, file_1.name])
inclusion_line_in_file_1 = single_line_sequence(
1, file_1_invalid_inclusion_line)
root_suite_file = File(
'0.suite',
lines_content([
phase_names.CLEANUP.syntax,
root_suite_inclusion_line,
]))
inclusion_line_in_root_file = single_line_sequence(
2, root_suite_inclusion_line)
expected_source_location_path = SourceLocationPath(
SourceLocation(
inclusion_line_in_file_1,
file_1.name_as_path,
), [
SourceLocation(
inclusion_line_in_root_file,
root_suite_file.name_as_path,
)
])
def root_suite_based_at(self, root_path: pathlib.Path) -> pathlib.Path:
return self.root_suite_file.name_as_path
def file_structure_to_read(self) -> DirContents:
return DirContents([self.root_suite_file, self.file_1])
def check_exception(self, root_path: pathlib.Path, actual: Exception,
put: unittest.TestCase):
put.assertIsInstance(actual, SuiteParseError)
expectation = matches_suite_parse_error(
suite_file=asrt.equals(self.root_suite_based_at(root_path)),
maybe_section_name=asrt.equals(phase_names.CLEANUP.plain),
source=equals_line_sequence(self.inclusion_line_in_file_1),
source_location=equals_source_location_path(
self.expected_source_location_path),
document_parser_exception=asrt.is_instance(
sec_doc_exceptions.FileAccessError),
)
expectation.apply(put, actual)
def file_structure_to_read(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File(
'main.suite',
lines_content([
section_names.CASES.syntax,
'1.case',
'sub/2.case',
])),
File.empty('1.case'),
Dir('sub', [File.empty('2.case')])
])
def file_structure(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File('main.suite', lines_content(['[cases]', 'the.case'])),
File(
'the.case',
lines_content([
'[act]', 'system-under-test', '[assert]',
'exit-code {eq} 0'.format(eq=comparators.EQ.name)
])),
python_executable_file('system-under-test',
PYTHON_PROGRAM_THAT_EXISTS_WITH_STATUS_0)
])
def file_structure_to_read(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
Dir('main-sub-dir', [
File(
'main.suite',
lines_content([
section_names.CASES.syntax,
'../main.case',
])),
]),
File.empty('main.case'),
])
def test_one_empty_and_one_non_empty_file(self):
self.instruction_checker.check_expectation_type_variants(
self.for_all__empty__arguments,
model.model_with_source_path_as_sub_dir_of_rel_root(self.name_of_checked_dir),
main_result_for_positive_expectation=PassOrFail.FAIL,
root_dir_of_dir_contents=AN_ACCEPTED_SDS_REL_OPT_CONFIG,
contents_of_relativity_option_root=DirContents([
Dir(self.name_of_checked_dir, [
File.empty('empty-file.txt'),
File('non-empty-file.txt', 'contents of non-empty file'),
]),
]),
)
def file_structure_to_read(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File(
'main.suite',
lines_content([
section_names.SUITES.syntax,
str(root_path / '1.suite'),
section_names.CASES.syntax,
str(root_path / '1.case'),
])),
File.empty('1.suite'),
File.empty('1.case'),
])
def test_WHEN_multiple_selectors_THEN_selection_SHOULD_be_conjunction_of_selectors(
self):
# ARRANGE #
prefix_to_include = 'A'
file_type_to_include = FileType.DIRECTORY
name = prefix_to_include + '-matching-base-name'
file_name = prefix_to_include + '-matching-base-name--file'
name1 = prefix_to_include + 'dir-in-dir-matching-base-name'
name2 = prefix_to_include + '-matching-base-name--dir-in-dir'
name3 = prefix_to_include + '-matching-base-name'
name4 = prefix_to_include + '-matching-base-name--empty-dir'
actual_cases = [
NameAndValue(
'empty',
[],
),
NameAndValue(
'single regular file that matches on base name',
[File.empty(name)],
),
NameAndValue(
'single dir that matches on base name',
[Dir.empty(name3)],
),
NameAndValue(
'single dir that not matches on base name',
[Dir.empty('non-matching-base-name')],
),
NameAndValue('directories with contents - one level', [
File.empty(file_name),
Dir.empty(name4),
Dir('non-matching-name-non-empty-dir', [
File.empty('file-in-dir'),
Dir.empty(name1),
]),
Dir(prefix_to_include + '-matching-base-name--non-empty-dir', [
File.empty('file-in-dir'),
Dir.empty(name2),
]),
]),
]
cases = test_data.strip_file_type_info_s(
test_data.filter_on_file_type(
file_type_to_include,
test_data.filter_on_base_name_prefix(prefix_to_include, [
test_data.expected_is_direct_contents_of_actual(
case.name, case.value) for case in actual_cases
])))
def _run(self, suite_file_name: str,
run_as_part_of_explicit_suite: Optional[Path]):
# ARRANGE #
default_test_case_handling = setup_with_null_act_phase_and_null_preprocessing(
)
conf_parser_with_no_instructions = configuration_section_parser({})
test_case_definition = test_case_definition_with_only_assert_phase_instructions(
[])
case_file = File.empty('test.case')
suite_file = File(
suite_file_name,
lines_content([
phase_names.ASSERT.syntax,
' '.join([
INCLUDING_DIRECTIVE_INFO.singular_name,
'non-existing-file.txt'
]),
]))
suite_and_case_files = DirContents([
suite_file,
case_file,
])
processor = sut.Processor(
test_case_definition,
os_services_access.new_for_cmd_exe(
CommandExecutorThatJustReturnsConstant()),
conf_parser_with_no_instructions, 2**10)
with tmp_dir_as_cwd(suite_and_case_files) as tmp_dir:
execution_settings = TestCaseExecutionSettings(
case_file.name_as_path,
tmp_dir,
ReportingOption.STATUS_CODE,
default_test_case_handling,
run_as_part_of_explicit_suite=run_as_part_of_explicit_suite)
# ACT #
actual_result = capture_output_from_processor(
processor, execution_settings)
# ASSERT #
expectation = is_result_for_exit_value(
exit_values.NO_EXECUTION__FILE_ACCESS_ERROR)
expectation.apply_without_message(self, actual_result)
def test_definition_in_suite_and_case(self):
# ARRANGE #
symbol_in_suite = 'SUITE_STRING_SYMBOL'
symbol_in_case__before_preproc = 'CASE_STRING_SYMBOL__BEFORE_PRE_PROC'
symbol_in_case__after_preproc = 'CASE_STRING_SYMBOL'
suite_with_preprocessor = File(
'with-preprocessor.suite',
lines_content([
section_names.CONFIGURATION.syntax,
suite_instructions.set_search_replace_preprocessor(
symbol_in_case__before_preproc,
symbol_in_case__after_preproc),
phase_names.SETUP.syntax,
sym_def.define_string(symbol_in_suite, 'suite-value'),
]))
case_with_single_def = File(
'test.case',
lines_content([
phase_names.SETUP.syntax,
sym_def.define_string(symbol_in_case__before_preproc,
'case-value'),
]))
# ACT & ASSERT #
test_with_files_in_tmp_dir.check(
self,
command_line_arguments=symbol_args.explicit_suite_and_case(
suite_with_preprocessor.name, case_with_single_def.name),
arrangement=Arrangement(
cwd_contents=DirContents([
suite_with_preprocessor,
case_with_single_def,
]),
main_program_config=sym_def.main_program_config(),
),
expectation=asrt_proc_result.sub_process_result(
exitcode=asrt.equals(exit_codes.EXIT_OK),
stdout=asrt.equals(
output.list_of([
output.SymbolSummary(symbol_in_suite,
ValueType.STRING,
num_refs=0),
output.SymbolSummary(symbol_in_case__after_preproc,
ValueType.STRING,
num_refs=0),
])),
))
def file_structure(self, root_path: pathlib.Path) -> DirContents:
exe_file = python_executable_file('executable-file',
PYTHON_PROGRAM_THAT_EXISTS_WITH_STATUS_0)
instruction_that_runs_program = '{run} {exe_file}'.format(
run=instruction_names.RUN_INSTRUCTION_NAME,
exe_file=exe_file.name,
)
return DirContents([
File('main.suite', lines_content(['[cases]', 'the.case'])),
File('the.case', lines_content(['[setup]',
instruction_that_runs_program,
])),
exe_file
])
def file_structure(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File(
'main.suite',
lines_content(
['[suites]', 'sub.suite', '[cases]', 'main.case'])),
File('main.case', ''),
File(
'sub.suite',
lines_content(
['[suites]', 'sub-sub.suite', '[cases]', 'sub.case'])),
File('sub.case', ''),
File('sub-sub.suite', ''),
])
def file_structure(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File('main.suite', lines_content(['[cases]', 'the.case'])),
File(
'the.case',
lines_content([
'[conf]',
'[setup]',
'[act]',
'[assert]',
'[before-assert]',
'[cleanup]',
])),
])
def file_structure(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File(
'main.suite',
lines_content(
['[cases]', 'sub-dir-1/?.case', 'sub-dir-2/*.case'])),
Dir('sub-dir-1', [
File.empty('b.case'),
File.empty('a.case'),
]),
Dir('sub-dir-2', [
File.empty('22.case'),
File.empty('11.case'),
]),
])
def file_structure_to_read(self, root_path: pathlib.Path) -> DirContents:
return DirContents([
File(
'main.suite',
lines_content([
section_names.SUITES.syntax,
'sub-dir/sub.suite',
])),
Dir('sub-dir', [
File('sub.suite', lines_content([
'sub.case',
])),
File.empty('sub.case')
])
])
