def file_must_not_exist_source_cases(file_name: str) -> Sequence[NameAndValue[FileSpecAbsStx]]:
file_name_syntax = StringLiteralAbsStx(file_name, QuoteType.HARD)
explicit_file_contents = str_src_abs_stx.StringSourceOfStringAbsStx.of_plain(
StringLiteralAbsStx.empty_string()
)
explicit_dir_contents = LiteralFilesSourceAbsStx(())
return [
NameAndValue(
'regular / implicit empty',
regular_file_spec(file_name_syntax,
FileContentsEmptyAbsStx()),
),
NameAndValue(
'regular / explicit creation',
regular_file_spec(file_name_syntax,
FileContentsExplicitAbsStx(ModificationType.CREATE,
explicit_file_contents)),
),
NameAndValue(
'dir / implicit empty',
dir_spec(file_name_syntax,
DirContentsEmptyAbsStx()),
),
NameAndValue(
'dir / explicit creation',
dir_spec(file_name_syntax,
DirContentsExplicitAbsStx(ModificationType.CREATE,
explicit_dir_contents)),
),
]
def test_failing_parse(self):
cases = [
NameAndValue(
'missing argument',
CustomAbsStx.empty(),
),
NameAndValue(
'missing end quote in file name',
LiteralFilesSourceAbsStx([
abs_stx.regular_file_spec(
MISSING_END_QUOTE__SOFT,
abs_stx.FileContentsEmptyAbsStx(),
)
])
),
NameAndValue(
'superfluous arguments',
SequenceAbsStx.followed_by_superfluous(
LiteralFilesSourceAbsStx([])
),
),
]
# ARRANGE #
for case in cases:
with self.subTest(case.name):
PARSE_CHECKER.check_invalid_syntax__abs_stx(
self,
_syntax_of(case.value)
)
def test_regular_file(self):
file_name = 'destination.txt'
file_name_syntax = StringLiteralAbsStx(file_name, QuoteType.HARD)
explicit_file_contents = str_src_abs_stx.StringSourceOfStringAbsStx.of_plain(
StringLiteralAbsStx.empty_string()
)
file_spec_syntax = regular_file_spec(
file_name_syntax,
FileContentsExplicitAbsStx(ModificationType.APPEND,
explicit_file_contents),
)
for dir_contents_case in file_must_exist_as_regular(file_name):
with self.subTest(dir_contents=dir_contents_case.name):
integration_check.CHECKER.check__abs_stx(
self,
LiteralFilesSourceAbsStx([file_spec_syntax]),
dir_contents_case.value,
arrangement_w_tcds(),
Expectation(
parse=IS_AT_END_OF_1ST_LNE,
execution=ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text(),
)
),
)
def test_dir(self):
# ARRANGE #
to_append_file = fs.File('file-to-append',
'contents of file to append')
pre_existing_file = fs.File('pre-existing',
'contents of pre existing file')
append_single_file__contents_syntax = abs_stx.DirContentsExplicitAbsStx(
ModificationType.APPEND,
abs_stx.LiteralFilesSourceAbsStx([
abs_stx.regular_file_spec(
file_name_arg(to_append_file.name),
abs_stx.FileContentsExplicitAbsStx(
ModificationType.CREATE,
str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
to_append_file.contents, QuoteType.HARD)))
]))
target_dir_name = 'destination-dir'
contents_cases: Sequence[AppendDirContentsCase] = [
AppendDirContentsCase(
'empty',
[],
[to_append_file],
),
AppendDirContentsCase(
'non-empty',
[pre_existing_file],
[pre_existing_file, to_append_file],
),
]
for target_location_case in target_locations():
syntax = abs_stx.LiteralFilesSourceAbsStx([
abs_stx.dir_spec(
file_name_arg(
target_location_case.target_rel_path(target_dir_name)),
append_single_file__contents_syntax,
)
])
for contents_case in contents_cases:
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
syntax, [
target_location_case.file_for_leaf(
contents_case.original(target_dir_name))
],
arrangement_w_tcds(),
MultiSourceExpectation(execution=ExecutionExpectation(
main_result=asrt_fs.dir_contains_exactly_2([
target_location_case.file_for_leaf(
fs.Dir(
target_dir_name, contents_case.
expected_contents_after_modification))
]))),
sub_test_identifiers={
'contents': contents_case.name,
'target_location': target_location_case.name
})
def test_regular(self):
# ARRANGE #
to_append__text = '<appended text>'
non_empty_original__text = '<original text>'
append_contents_syntax = abs_stx.FileContentsExplicitAbsStx(
ModificationType.APPEND,
str_src_abs_stx.StringSourceOfStringAbsStx.of_str_hard(
to_append__text))
name_of_modified_file = 'destination.txt'
contents_cases: Sequence[AppendRegularContentsCase] = [
AppendRegularContentsCase(
'empty',
'',
to_append__text,
),
AppendRegularContentsCase(
'non-empty',
non_empty_original__text,
non_empty_original__text + to_append__text,
),
]
for target_location_case in target_locations():
syntax = abs_stx.LiteralFilesSourceAbsStx([
abs_stx.regular_file_spec(
file_name_arg(
target_location_case.target_rel_path(
name_of_modified_file)),
append_contents_syntax,
)
])
for contents_case in contents_cases:
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
syntax, [
target_location_case.file_for_leaf(
contents_case.original(name_of_modified_file))
],
arrangement_w_tcds(),
MultiSourceExpectation(execution=ExecutionExpectation(
main_result=asrt_fs.dir_contains_exactly_2([
target_location_case.file_for_leaf(
fs.File(
name_of_modified_file, contents_case.
expected_contents_after_modification))
]))),
sub_test_identifiers={
'contents': contents_case.name,
'target_location': target_location_case.name
})
def test_regular_file(self):
valid_file_name = StringLiteralAbsStx('valid_file_name')
for validation_case in str_src_validation_cases.failing_validation_cases():
symbol_context = validation_case.value.symbol_context
for contents_case in ContentsCase.cases():
invalid_file_spec = abs_stx.regular_file_spec(
valid_file_name,
abs_stx.FileContentsExplicitAbsStx(contents_case.modification_type,
symbol_context.abstract_syntax),
)
# ACT & ASSERT #
self._check_case(
invalid_file_spec,
contents_case,
validation_case,
)
def test_illegal_path_with_regular_file_as_dir_component(self):
# ARRANGE #
existing_regular_file = fs.File.empty('regular-file')
file_name = str(PurePosixPath(existing_regular_file.name, 'destination'))
file_name_syntax = StringLiteralAbsStx(file_name, QuoteType.HARD)
explicit_file_contents = str_src_abs_stx.StringSourceOfStringAbsStx.of_plain(
StringLiteralAbsStx.empty_string()
)
file_spec_cases = [
NameAndValue(
'regular',
regular_file_spec(
file_name_syntax,
FileContentsExplicitAbsStx(ModificationType.APPEND,
explicit_file_contents),
),
),
NameAndValue(
'dir',
dir_spec(
file_name_syntax,
DirContentsExplicitAbsStx(ModificationType.APPEND,
LiteralFilesSourceAbsStx(())),
),
),
]
for file_spec_case in file_spec_cases:
with self.subTest(file_spec=file_spec_case.name):
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx(
self,
LiteralFilesSourceAbsStx([file_spec_case.value]),
[existing_regular_file],
arrangement_w_tcds(),
Expectation(
parse=IS_AT_END_OF_1ST_LNE,
execution=ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text(),
)
),
)
def test_literal(self):
# ARRANGE #
defined_name = symbol_syntax.A_VALID_SYMBOL_NAME
create_file = fs.File('created-file.txt',
'contents of created file')
literal_syntax = abs_stx.LiteralFilesSourceAbsStx([
abs_stx.regular_file_spec(
StringLiteralAbsStx(create_file.name, QuoteType.HARD),
abs_stx.FileContentsExplicitAbsStx(
ModificationType.CREATE,
StringSourceOfStringAbsStx.of_str(create_file.contents,
QuoteType.HARD),
)
)
])
syntax = _syntax_of(
literal_syntax,
defined_name,
)
arrangement = Arrangement.phase_agnostic()
# EXPECTATION #
expectation = _expect_definition_of(
defined_name,
SymbolTable.empty(),
(),
asrt.is_empty_sequence,
asrt_fs.dir_contains_exactly_2([create_file])
)
# ACT & ASSERT #
INSTRUCTION_CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
syntax,
arrangement,
expectation,
)
INVALID_FILE_NAMES: Sequence[NameAndValue[str]] = [
NameAndValue('empty', ''),
NameAndValue('absolute', '/a/b/c'),
NameAndValue('relative component (double dot)', 'b/../c'),
NameAndValue('os path separator (posix)', 'a/:b/c'),
NameAndValue('os path separator (windows)', 'a/b;/c'),
]
OTHER_VALID_FILE_SPECS: Sequence[NameAndValue[List[FileSpecAbsStx]]] = [
NameAndValue(
'none',
[]),
NameAndValue(
'valid',
[
abs_stx.regular_file_spec(StringLiteralAbsStx('valid', QuoteType.HARD),
abs_stx.FileContentsEmptyAbsStx())
]),
]
def file_type_and_contents_variants(file_name: StringAbsStx) -> Sequence[NameAndValue[FileSpecAbsStx]]:
return [
NameAndValue(
'file_type={}, contents={}'.format(file_type, contents_variant.name),
abs_stx.FileSpecAbsStx.of_file_type(file_type,
file_name,
contents_variant.value)
)
for file_type in defs.FileType
for contents_variant in _CONTENTS_CASES[file_type]
]
def create_path_cases(
created_leaf_file_name: str) -> Sequence[FileSpecAndExpectedCase]:
explicit_file_contents = 'explicit file contents'
name_of_created_file_in_dir = 'file-in-dir.txt'
name_of_sub_dir = 'created-sub-dir'
file_in_created_dir__file_spec = abs_stx.regular_file_spec(
StringLiteralAbsStx(name_of_created_file_in_dir, QuoteType.HARD),
abs_stx.FileContentsEmptyAbsStx(),
)
return [
FileSpecAndExpectedCase(
'regular / implicit empty',
FileType.REGULAR,
abs_stx.FileContentsEmptyAbsStx(),
fs.File.empty(created_leaf_file_name),
),
FileSpecAndExpectedCase(
'regular / explicit contents',
FileType.REGULAR,
abs_stx.FileContentsExplicitAbsStx(
ModificationType.CREATE,
str_src_abs_stx.StringSourceOfStringAbsStx.of_str_hard(
explicit_file_contents)),
fs.File(created_leaf_file_name, explicit_file_contents),
),
FileSpecAndExpectedCase(
'dir / implicit empty',
FileType.DIR,
abs_stx.DirContentsEmptyAbsStx(),
fs.Dir.empty(created_leaf_file_name),
),
FileSpecAndExpectedCase(
'dir / explicit contents',
FileType.DIR,
abs_stx.DirContentsExplicitAbsStx(
ModificationType.CREATE,
abs_stx.LiteralFilesSourceAbsStx(
[file_in_created_dir__file_spec])),
fs.Dir(created_leaf_file_name,
[fs.File.empty(name_of_created_file_in_dir)]),
),
FileSpecAndExpectedCase(
'dir / explicit contents / nested dirs',
FileType.DIR,
abs_stx.DirContentsExplicitAbsStx(
ModificationType.CREATE,
abs_stx.LiteralFilesSourceAbsStx([
abs_stx.dir_spec(
file_name_arg(name_of_sub_dir),
abs_stx.DirContentsExplicitAbsStx(
ModificationType.CREATE,
abs_stx.LiteralFilesSourceAbsStx([
file_in_created_dir__file_spec,
])),
)
])),
fs.Dir(created_leaf_file_name, [
fs.Dir(name_of_sub_dir,
[fs.File.empty(name_of_created_file_in_dir)])
]),
),
]