def _file_contents_cases(self) -> InvalidDestinationFileTestCasesData:
file_contents_cases = [
NameAndValue('empty file', fs_abs_stx.FileContentsEmptyAbsStx()),
]
return InvalidDestinationFileTestCasesData(file_contents_cases,
SymbolTable({}))
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 runTest(self):
# ARRANGE #
missing_contents_file_spec = abs_stx.FileSpecAbsStx(
'invalid_file_type_token', StringLiteralAbsStx('valid_file_name'),
abs_stx.FileContentsEmptyAbsStx())
literal_syntax = abs_stx.LiteralFilesSourceAbsStx(
[missing_contents_file_spec])
# ACT & ASSERT #
integration_check.PARSE_CHECKER__FULL.check_invalid_syntax__abs_stx(
self,
literal_syntax,
)
def runTest(self):
# ARRANGE #
valid_file_specs_cases: Sequence[NameAndValue[
Sequence[FileSpecAbsStx]]] = [
NameAndValue(
'none',
(),
),
NameAndValue(
'single valid',
[
abs_stx.regular_file_spec__str_name(
'valid_file_name',
abs_stx.FileContentsEmptyAbsStx())
],
),
]
invalid_delimiters_cases: Sequence[NameAndValue[Tuple[str, str]]] = [
NameAndValue(
'start missing',
('', syntax.FILE_LIST_END),
),
NameAndValue(
'start is end',
(syntax.FILE_LIST_END, syntax.FILE_LIST_END),
),
NameAndValue(
'end missing',
(syntax.FILE_LIST_BEGIN, ''),
),
NameAndValue(
'end is start',
(syntax.FILE_LIST_BEGIN, syntax.FILE_LIST_BEGIN),
),
]
for valid_file_specs_case in valid_file_specs_cases:
for invalid_delimiters_case in invalid_delimiters_cases:
# ACT & ASSERT #
integration_check.PARSE_CHECKER__FULL.check_invalid_syntax__abs_stx(
self,
LiteralFilesSourceAbsStx(
valid_file_specs_case.value,
delimiter__begin=invalid_delimiters_case.value[0],
delimiter__end=invalid_delimiters_case.value[1],
),
sub_test_identifiers={
'file_specs': valid_file_specs_case.name,
'delimiters': invalid_delimiters_case.name,
})
def _successful__append() -> ContentsCase:
created_file = fs.File.empty('created-regular-file')
dst_dir = fs.Dir('destination-dir', [
created_file,
])
return ContentsCase(
'create',
dst_dir.name,
fs_abs_stx.DirContentsExplicitAbsStx(
ModificationType.APPEND,
fs_abs_stx.LiteralFilesSourceAbsStx([
fs_abs_stx.regular_file_spec__str_name(
created_file.name,
fs_abs_stx.FileContentsEmptyAbsStx(),
)
])
),
pre_existing_files=[fs.Dir.empty(dst_dir.name)],
expected_files=[dst_dir]
)
def _successful__create() -> ContentsCase:
created_file = fs.File.empty('created-regular-file')
created_dir = fs.Dir('created-dir', [
created_file,
])
return ContentsCase(
'create',
created_dir.name,
fs_abs_stx.DirContentsExplicitAbsStx(
ModificationType.CREATE,
fs_abs_stx.LiteralFilesSourceAbsStx([
fs_abs_stx.regular_file_spec__str_name(
created_file.name,
fs_abs_stx.FileContentsEmptyAbsStx(),
)
])
),
pre_existing_files=(),
expected_files=[created_dir]
)
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)])
]),
),
]
def without_contents(destination: PathAbsStx) -> InstructionAbsStx:
return InstructionAbsStx(destination, fs_abs_stx.FileContentsEmptyAbsStx())
def runTest(self):
fn_f_1 = _fn_symbol('file__name__1', 'file-1.txt')
fn_f_2 = _fn_symbol('file__name__2', 'file-2.txt')
fn_f_3 = _fn_symbol('file__name__3', fn_f_2.str_value)
fn_d_1 = _fn_symbol('dir__name__1', 'dir-1')
fn_d_2 = _fn_symbol('dir__name__2', 'dir-2')
fn_d_3 = _fn_symbol('dir__name__3', fn_d_2.str_value)
contents_f_2 = StringSourceSymbolContextOfPrimitiveConstant('file_contents_2', 'contents of file 2')
contents_f_3 = StringSourceSymbolContextOfPrimitiveConstant('file_contents_3', 'contents of file 3')
contents_d_2 = FilesSourceSymbolContext.of_primitive('dir_contents_2',
primitives.FilesSourceThatDoesNothingTestImpl())
contents_d_3 = FilesSourceSymbolContext.of_primitive('dir_contents_3',
primitives.FilesSourceThatDoesNothingTestImpl())
expected_created_files = [
fs.File.empty(fn_f_1.str_value),
fs.File(fn_f_2.str_value, contents_f_2.contents_str + contents_f_3.contents_str),
fs.Dir.empty(fn_d_1.str_value),
fs.Dir.empty(fn_d_2.str_value),
]
all_symbols = [
fn_f_1,
fn_f_2, contents_f_2,
fn_f_3, contents_f_3,
fn_d_1,
fn_d_2, contents_d_2,
fn_d_3, contents_d_3,
]
syntax = LiteralFilesSourceAbsStx([
_spec_regular(fn_f_1,
abs_stx.FileContentsEmptyAbsStx()),
_spec_regular(fn_f_2,
abs_stx.FileContentsExplicitAbsStx(
ModificationType.CREATE,
contents_f_2.abstract_syntax,
)),
_spec_regular(fn_f_3,
abs_stx.FileContentsExplicitAbsStx(
ModificationType.APPEND,
contents_f_3.abstract_syntax,
)),
_spec_dir(fn_d_1,
abs_stx.DirContentsEmptyAbsStx()),
_spec_dir(fn_d_2,
abs_stx.DirContentsExplicitAbsStx(
ModificationType.CREATE,
contents_d_2.abstract_syntax,
)),
_spec_dir(fn_d_3,
abs_stx.DirContentsExplicitAbsStx(
ModificationType.APPEND,
contents_d_3.abstract_syntax,
)),
])
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx__layout__std_source_variants(
self,
syntax,
(),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(all_symbols)
),
MultiSourceExpectation(
symbol_references=SymbolContext.references_assertion_of_contexts(all_symbols),
execution=ExecutionExpectation(
main_result=asrt_fs.dir_contains_exactly_2(
expected_created_files
)
)
)
)
