201 lines
6 KiB
Python
201 lines
6 KiB
Python
"""Unit tests: parse_encrypt"""
|
|
|
|
import pytest
|
|
|
|
|
|
def test_not_called(runner, paths):
|
|
"""Test parse_encrypt (not called)"""
|
|
run = run_parse_encrypt(runner, paths, skip_parse=True)
|
|
assert run.success
|
|
assert run.err == ''
|
|
assert 'EIF:unparsed' in run.out, 'EIF should be unparsed'
|
|
assert 'EIF_COUNT:1' in run.out, 'Only value of EIF should be unparsed'
|
|
|
|
|
|
def test_short_circuit(runner, paths):
|
|
"""Test parse_encrypt (short-circuit)"""
|
|
run = run_parse_encrypt(runner, paths, twice=True)
|
|
assert run.success
|
|
assert run.err == ''
|
|
assert 'PARSE_ENCRYPT_SHORT=parse_encrypt() not reprocessed' in run.out, (
|
|
'parse_encrypt() should short-circuit')
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
'encrypt', [
|
|
('missing'),
|
|
('empty'),
|
|
])
|
|
def test_empty(runner, paths, encrypt):
|
|
"""Test parse_encrypt (file missing/empty)"""
|
|
|
|
# write encrypt file
|
|
if encrypt == 'missing':
|
|
assert not paths.encrypt.exists(), 'Encrypt should be missing'
|
|
else:
|
|
paths.encrypt.write('')
|
|
assert paths.encrypt.exists(), 'Encrypt should exist'
|
|
assert paths.encrypt.size() == 0, 'Encrypt should be empty'
|
|
|
|
# run parse_encrypt
|
|
run = run_parse_encrypt(runner, paths)
|
|
assert run.success
|
|
assert run.err == ''
|
|
|
|
# validate parsing result
|
|
assert 'EIF_COUNT:0' in run.out, 'EIF should be empty'
|
|
|
|
|
|
def create_test_encrypt_data(paths):
|
|
"""Generate test data for testing encrypt"""
|
|
|
|
edata = ''
|
|
expected = set()
|
|
|
|
# empty line
|
|
edata += '\n'
|
|
|
|
# simple comments
|
|
edata += '# a simple comment\n'
|
|
edata += ' # a comment with leading space\n'
|
|
|
|
# unreferenced directory
|
|
paths.work.join('unreferenced').mkdir()
|
|
|
|
# simple files
|
|
edata += 'simple_file\n'
|
|
edata += 'simple.file\n'
|
|
paths.work.join('simple_file').write('')
|
|
paths.work.join('simple.file').write('')
|
|
paths.work.join('simple_file2').write('')
|
|
paths.work.join('simple.file2').write('')
|
|
expected.add('simple_file')
|
|
expected.add('simple.file')
|
|
|
|
# simple files in directories
|
|
edata += 'simple_dir/simple_file\n'
|
|
paths.work.join('simple_dir/simple_file').write('', ensure=True)
|
|
paths.work.join('simple_dir/simple_file2').write('', ensure=True)
|
|
expected.add('simple_dir/simple_file')
|
|
|
|
# paths with spaces
|
|
edata += 'with space/with space\n'
|
|
paths.work.join('with space/with space').write('', ensure=True)
|
|
paths.work.join('with space/with space2').write('', ensure=True)
|
|
expected.add('with space/with space')
|
|
|
|
# hidden files
|
|
edata += '.hidden\n'
|
|
paths.work.join('.hidden').write('')
|
|
expected.add('.hidden')
|
|
|
|
# hidden files in directories
|
|
edata += '.hidden_dir/.hidden_file\n'
|
|
paths.work.join('.hidden_dir/.hidden_file').write('', ensure=True)
|
|
expected.add('.hidden_dir/.hidden_file')
|
|
|
|
# wildcards
|
|
edata += 'wild*\n'
|
|
paths.work.join('wildcard1').write('', ensure=True)
|
|
paths.work.join('wildcard2').write('', ensure=True)
|
|
expected.add('wildcard1')
|
|
expected.add('wildcard2')
|
|
|
|
edata += 'dirwild*\n'
|
|
paths.work.join('dirwildcard/file1').write('', ensure=True)
|
|
paths.work.join('dirwildcard/file2').write('', ensure=True)
|
|
expected.add('dirwildcard')
|
|
|
|
# excludes
|
|
edata += 'exclude*\n'
|
|
edata += 'ex ex/*\n'
|
|
paths.work.join('exclude_file1').write('')
|
|
paths.work.join('exclude_file2.ex').write('')
|
|
paths.work.join('exclude_file3.ex3').write('')
|
|
expected.add('exclude_file1')
|
|
expected.add('exclude_file3.ex3')
|
|
edata += '!*.ex\n'
|
|
edata += '!ex ex/*.txt\n'
|
|
paths.work.join('ex ex/file4').write('', ensure=True)
|
|
paths.work.join('ex ex/file5.txt').write('', ensure=True)
|
|
paths.work.join('ex ex/file6.text').write('', ensure=True)
|
|
expected.add('ex ex/file4')
|
|
expected.add('ex ex/file6.text')
|
|
|
|
# double star
|
|
edata += 'doublestar/**/file*\n'
|
|
edata += '!**/file3\n'
|
|
paths.work.join('doublestar/a/b/file1').write('', ensure=True)
|
|
paths.work.join('doublestar/c/d/file2').write('', ensure=True)
|
|
paths.work.join('doublestar/e/f/file3').write('', ensure=True)
|
|
paths.work.join('doublestar/g/h/nomatch').write('', ensure=True)
|
|
expected.add('doublestar/a/b/file1')
|
|
expected.add('doublestar/c/d/file2')
|
|
# doublestar/e/f/file3 is excluded
|
|
|
|
return edata, expected
|
|
|
|
|
|
@pytest.mark.usefixtures('ds1_repo_copy')
|
|
def test_file_parse_encrypt(runner, paths):
|
|
"""Test parse_encrypt
|
|
|
|
Test an array of supported features of the encrypt configuration.
|
|
"""
|
|
|
|
# generate test data & expectations
|
|
edata, expected = create_test_encrypt_data(paths)
|
|
|
|
# write encrypt file
|
|
print(f'ENCRYPT:\n---\n{edata}---\n')
|
|
paths.encrypt.write(edata)
|
|
assert paths.encrypt.isfile()
|
|
|
|
# run parse_encrypt
|
|
run = run_parse_encrypt(runner, paths)
|
|
assert run.success
|
|
assert run.err == ''
|
|
|
|
assert f'EIF_COUNT:{len(expected)}' in run.out, 'EIF count wrong'
|
|
for expected_file in expected:
|
|
assert f'EIF:{expected_file}\n' in run.out
|
|
|
|
sorted_expectations = '\n'.join(
|
|
[f'EIF:{exp}' for exp in sorted(expected)])
|
|
assert sorted_expectations in run.out
|
|
|
|
|
|
def run_parse_encrypt(
|
|
runner, paths,
|
|
skip_parse=False,
|
|
twice=False):
|
|
"""Run parse_encrypt
|
|
|
|
A count of ENCRYPT_INCLUDE_FILES will be reported as EIF_COUNT:X. All
|
|
values of ENCRYPT_INCLUDE_FILES will be reported as individual EIF:value
|
|
lines.
|
|
"""
|
|
parse_cmd = 'parse_encrypt'
|
|
if skip_parse:
|
|
parse_cmd = ''
|
|
if twice:
|
|
parse_cmd = 'parse_encrypt; parse_encrypt'
|
|
script = f"""
|
|
YADM_TEST=1 source {paths.pgm}
|
|
YADM_ENCRYPT={paths.encrypt}
|
|
export YADM_ENCRYPT
|
|
GIT_DIR={paths.repo}
|
|
export GIT_DIR
|
|
YADM_WORK={paths.work}
|
|
export YADM_WORK
|
|
{parse_cmd}
|
|
export ENCRYPT_INCLUDE_FILES
|
|
export PARSE_ENCRYPT_SHORT
|
|
env
|
|
echo EIF_COUNT:${{#ENCRYPT_INCLUDE_FILES[@]}}
|
|
for value in "${{ENCRYPT_INCLUDE_FILES[@]}}"; do
|
|
echo "EIF:$value"
|
|
done
|
|
"""
|
|
run = runner(command=['bash'], inp=script)
|
|
return run
|