parent
f3ae31f1c2
commit
cfda485b34
@ -0,0 +1,193 @@
|
||||
"""Test alt"""
|
||||
import os
|
||||
import string
|
||||
import py
|
||||
import pytest
|
||||
import utils
|
||||
|
||||
TEST_PATHS = [utils.ALT_FILE1, utils.ALT_FILE2, utils.ALT_DIR]
|
||||
|
||||
|
||||
@pytest.mark.usefixtures('ds1_copy')
|
||||
@pytest.mark.parametrize(
|
||||
'tracked,encrypt,exclude', [
|
||||
(False, False, False),
|
||||
(True, False, False),
|
||||
(False, True, False),
|
||||
(False, True, True),
|
||||
], ids=['untracked', 'tracked', 'encrypted', 'excluded'])
|
||||
def test_alt_source(
|
||||
runner, yadm_y, paths,
|
||||
tracked, encrypt, exclude):
|
||||
"""Test yadm alt operates on all expected sources of alternates"""
|
||||
|
||||
utils.create_alt_files(
|
||||
paths, '##default', tracked=tracked, encrypt=encrypt, exclude=exclude)
|
||||
run = runner(yadm_y('alt'))
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
linked = utils.parse_alt_output(run.out)
|
||||
|
||||
for link_path in TEST_PATHS:
|
||||
source_file = link_path + '##default'
|
||||
if tracked or (encrypt and not exclude):
|
||||
assert paths.work.join(link_path).islink()
|
||||
target = py.path.local(paths.work.join(link_path).readlink())
|
||||
if target.isfile():
|
||||
assert paths.work.join(link_path).read() == source_file
|
||||
assert str(paths.work.join(source_file)) in linked
|
||||
else:
|
||||
assert paths.work.join(link_path).join(
|
||||
utils.CONTAINED).read() == source_file
|
||||
assert str(paths.work.join(source_file)) in linked
|
||||
else:
|
||||
assert not paths.work.join(link_path).exists()
|
||||
assert str(paths.work.join(source_file)) not in linked
|
||||
|
||||
|
||||
@pytest.mark.usefixtures('ds1_copy')
|
||||
@pytest.mark.parametrize('suffix', [
|
||||
'##default',
|
||||
'##o.$tst_sys', '##os.$tst_sys',
|
||||
'##c.$tst_class', '##class.$tst_class',
|
||||
'##h.$tst_host', '##hostname.$tst_host',
|
||||
'##u.$tst_user', '##user.$tst_user',
|
||||
])
|
||||
def test_alt_conditions(
|
||||
runner, yadm_y, paths,
|
||||
tst_sys, tst_host, tst_user, suffix):
|
||||
"""Test conditions supported by yadm alt"""
|
||||
|
||||
# set the class
|
||||
tst_class = 'testclass'
|
||||
utils.set_local(paths, 'class', tst_class)
|
||||
|
||||
suffix = string.Template(suffix).substitute(
|
||||
tst_sys=tst_sys,
|
||||
tst_class=tst_class,
|
||||
tst_host=tst_host,
|
||||
tst_user=tst_user,
|
||||
)
|
||||
|
||||
utils.create_alt_files(paths, suffix)
|
||||
run = runner(yadm_y('alt'))
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
linked = utils.parse_alt_output(run.out)
|
||||
|
||||
for link_path in TEST_PATHS:
|
||||
source_file = link_path + suffix
|
||||
assert paths.work.join(link_path).islink()
|
||||
target = py.path.local(paths.work.join(link_path).readlink())
|
||||
if target.isfile():
|
||||
assert paths.work.join(link_path).read() == source_file
|
||||
assert str(paths.work.join(source_file)) in linked
|
||||
else:
|
||||
assert paths.work.join(link_path).join(
|
||||
utils.CONTAINED).read() == source_file
|
||||
assert str(paths.work.join(source_file)) in linked
|
||||
|
||||
|
||||
@pytest.mark.usefixtures('ds1_copy')
|
||||
@pytest.mark.parametrize('kind', ['builtin', '', 'envtpl', 'j2cli', 'j2'])
|
||||
@pytest.mark.parametrize('label', ['t', 'template', 'yadm', ])
|
||||
def test_alt_templates(
|
||||
runner, yadm_y, paths, kind, label):
|
||||
"""Test templates supported by yadm alt"""
|
||||
|
||||
suffix = f'##{label}.{kind}'
|
||||
utils.create_alt_files(paths, suffix)
|
||||
run = runner(yadm_y('alt'))
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
created = utils.parse_alt_output(run.out, linked=False)
|
||||
|
||||
for created_path in TEST_PATHS:
|
||||
if created_path != utils.ALT_DIR:
|
||||
source_file = created_path + suffix
|
||||
assert paths.work.join(created_path).isfile()
|
||||
assert paths.work.join(created_path).read().strip() == source_file
|
||||
assert str(paths.work.join(source_file)) in created
|
||||
|
||||
|
||||
@pytest.mark.usefixtures('ds1_copy')
|
||||
@pytest.mark.parametrize('autoalt', [None, 'true', 'false'])
|
||||
def test_auto_alt(runner, yadm_y, paths, autoalt):
|
||||
"""Test auto alt"""
|
||||
|
||||
# set the value of auto-alt
|
||||
if autoalt:
|
||||
os.system(' '.join(yadm_y('config', 'yadm.auto-alt', autoalt)))
|
||||
|
||||
utils.create_alt_files(paths, '##default')
|
||||
run = runner(yadm_y('status'))
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
linked = utils.parse_alt_output(run.out)
|
||||
|
||||
for link_path in TEST_PATHS:
|
||||
source_file = link_path + '##default'
|
||||
if autoalt == 'false':
|
||||
assert not paths.work.join(link_path).exists()
|
||||
else:
|
||||
assert paths.work.join(link_path).islink()
|
||||
target = py.path.local(paths.work.join(link_path).readlink())
|
||||
if target.isfile():
|
||||
assert paths.work.join(link_path).read() == source_file
|
||||
# no linking output when run via auto-alt
|
||||
assert str(paths.work.join(source_file)) not in linked
|
||||
else:
|
||||
assert paths.work.join(link_path).join(
|
||||
utils.CONTAINED).read() == source_file
|
||||
# no linking output when run via auto-alt
|
||||
assert str(paths.work.join(source_file)) not in linked
|
||||
|
||||
|
||||
@pytest.mark.usefixtures('ds1_copy')
|
||||
def test_stale_link_removal(runner, yadm_y, paths):
|
||||
"""Stale links to alternative files are removed
|
||||
|
||||
This test ensures that when an already linked alternative becomes invalid
|
||||
due to a change in class, the alternate link is removed.
|
||||
"""
|
||||
|
||||
# set the class
|
||||
tst_class = 'testclass'
|
||||
utils.set_local(paths, 'class', tst_class)
|
||||
|
||||
# create files which match the test class
|
||||
utils.create_alt_files(paths, f'##class.{tst_class}')
|
||||
|
||||
# run alt to trigger linking
|
||||
run = runner(yadm_y('alt'))
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
linked = utils.parse_alt_output(run.out)
|
||||
|
||||
# assert the proper linking has occurred
|
||||
for stale_path in TEST_PATHS:
|
||||
source_file = stale_path + '##class.' + tst_class
|
||||
assert paths.work.join(stale_path).islink()
|
||||
target = py.path.local(paths.work.join(stale_path).readlink())
|
||||
if target.isfile():
|
||||
assert paths.work.join(stale_path).read() == source_file
|
||||
assert str(paths.work.join(source_file)) in linked
|
||||
else:
|
||||
assert paths.work.join(stale_path).join(
|
||||
utils.CONTAINED).read() == source_file
|
||||
assert str(paths.work.join(source_file)) in linked
|
||||
|
||||
# change the class so there are no valid alternates
|
||||
utils.set_local(paths, 'class', 'changedclass')
|
||||
|
||||
# run alt to trigger linking
|
||||
run = runner(yadm_y('alt'))
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
linked = utils.parse_alt_output(run.out)
|
||||
|
||||
# assert the linking is removed
|
||||
for stale_path in TEST_PATHS:
|
||||
source_file = stale_path + '##class.' + tst_class
|
||||
assert not paths.work.join(stale_path).exists()
|
||||
assert str(paths.work.join(source_file)) not in linked
|
@ -0,0 +1,61 @@
|
||||
"""Unit tests: choose_template_cmd"""
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.mark.parametrize('label', ['', 'builtin', 'other'])
|
||||
@pytest.mark.parametrize('awk', [True, False], ids=['awk', 'no-awk'])
|
||||
def test_kind_builtin(runner, yadm, awk, label):
|
||||
"""Test kind: builtin"""
|
||||
|
||||
expected = 'template_builtin'
|
||||
awk_avail = 'true'
|
||||
|
||||
if not awk:
|
||||
awk_avail = 'false'
|
||||
expected = ''
|
||||
|
||||
if label == 'other':
|
||||
expected = ''
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
function awk_available {{ { awk_avail}; }}
|
||||
template="$(choose_template_cmd "{label}")"
|
||||
echo "TEMPLATE:$template"
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert f'TEMPLATE:{expected}\n' in run.out
|
||||
|
||||
|
||||
@pytest.mark.parametrize('label', ['envtpl', 'j2cli', 'j2', 'other'])
|
||||
@pytest.mark.parametrize('envtpl', [True, False], ids=['envtpl', 'no-envtpl'])
|
||||
@pytest.mark.parametrize('j2cli', [True, False], ids=['j2cli', 'no-j2cli'])
|
||||
def test_kind_j2cli_envtpl(runner, yadm, envtpl, j2cli, label):
|
||||
"""Test kind: j2 (both j2cli & envtpl)
|
||||
|
||||
j2cli is preferred over envtpl if available.
|
||||
"""
|
||||
|
||||
envtpl_avail = 'true' if envtpl else 'false'
|
||||
j2cli_avail = 'true' if j2cli else 'false'
|
||||
|
||||
if label in ('j2cli', 'j2') and j2cli:
|
||||
expected = 'template_j2cli'
|
||||
elif label in ('envtpl', 'j2') and envtpl:
|
||||
expected = 'template_envtpl'
|
||||
else:
|
||||
expected = ''
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
function envtpl_available {{ { envtpl_avail}; }}
|
||||
function j2cli_available {{ { j2cli_avail}; }}
|
||||
template="$(choose_template_cmd "{label}")"
|
||||
echo "TEMPLATE:$template"
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert f'TEMPLATE:{expected}\n' in run.out
|
@ -0,0 +1,114 @@
|
||||
"""Unit tests: record_score"""
|
||||
import pytest
|
||||
|
||||
INIT_VARS = """
|
||||
score=0
|
||||
local_class=testclass
|
||||
local_system=testsystem
|
||||
local_host=testhost
|
||||
local_user=testuser
|
||||
alt_scores=()
|
||||
alt_filenames=()
|
||||
alt_targets=()
|
||||
alt_template_cmds=()
|
||||
"""
|
||||
|
||||
REPORT_RESULTS = """
|
||||
echo "SIZE:${#alt_scores[@]}"
|
||||
echo "SCORES:${alt_scores[@]}"
|
||||
echo "FILENAMES:${alt_filenames[@]}"
|
||||
echo "TARGETS:${alt_targets[@]}"
|
||||
"""
|
||||
|
||||
|
||||
def test_dont_record_zeros(runner, yadm):
|
||||
"""Record nothing if the score is zero"""
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
{INIT_VARS}
|
||||
record_score "0" "testfile" "testtarget"
|
||||
{REPORT_RESULTS}
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert 'SIZE:0\n' in run.out
|
||||
assert 'SCORES:\n' in run.out
|
||||
assert 'FILENAMES:\n' in run.out
|
||||
assert 'TARGETS:\n' in run.out
|
||||
|
||||
|
||||
def test_new_scores(runner, yadm):
|
||||
"""Test new scores"""
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
{INIT_VARS}
|
||||
record_score "1" "file_one" "targ_one"
|
||||
record_score "2" "file_two" "targ_two"
|
||||
record_score "4" "file_three" "targ_three"
|
||||
{REPORT_RESULTS}
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert 'SIZE:3\n' in run.out
|
||||
assert 'SCORES:1 2 4\n' in run.out
|
||||
assert 'FILENAMES:file_one file_two file_three\n' in run.out
|
||||
assert 'TARGETS:targ_one targ_two targ_three\n' in run.out
|
||||
|
||||
|
||||
@pytest.mark.parametrize('difference', ['lower', 'equal', 'higher'])
|
||||
def test_existing_scores(runner, yadm, difference):
|
||||
"""Test existing scores"""
|
||||
|
||||
expected_score = '2'
|
||||
expected_target = 'existing_target'
|
||||
if difference == 'lower':
|
||||
score = '1'
|
||||
elif difference == 'equal':
|
||||
score = '2'
|
||||
else:
|
||||
score = '4'
|
||||
expected_score = '4'
|
||||
expected_target = 'new_target'
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
{INIT_VARS}
|
||||
alt_scores=(2)
|
||||
alt_filenames=("testfile")
|
||||
alt_targets=("existing_target")
|
||||
record_score "{score}" "testfile" "new_target"
|
||||
{REPORT_RESULTS}
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert 'SIZE:1\n' in run.out
|
||||
assert f'SCORES:{expected_score}\n' in run.out
|
||||
assert 'FILENAMES:testfile\n' in run.out
|
||||
assert f'TARGETS:{expected_target}\n' in run.out
|
||||
|
||||
|
||||
def test_existing_template(runner, yadm):
|
||||
"""Record nothing if a template command is registered for this file"""
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
{INIT_VARS}
|
||||
alt_scores=(1)
|
||||
alt_filenames=("testfile")
|
||||
alt_targets=()
|
||||
alt_template_cmds=("existing_template")
|
||||
record_score "2" "testfile" "new_target"
|
||||
{REPORT_RESULTS}
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert 'SIZE:1\n' in run.out
|
||||
assert 'SCORES:1\n' in run.out
|
||||
assert 'FILENAMES:testfile\n' in run.out
|
||||
assert 'TARGETS:\n' in run.out
|
@ -0,0 +1,55 @@
|
||||
"""Unit tests: record_template"""
|
||||
|
||||
INIT_VARS = """
|
||||
alt_filenames=()
|
||||
alt_template_cmds=()
|
||||
alt_targets=()
|
||||
"""
|
||||
|
||||
REPORT_RESULTS = """
|
||||
echo "SIZE:${#alt_filenames[@]}"
|
||||
echo "FILENAMES:${alt_filenames[@]}"
|
||||
echo "CMDS:${alt_template_cmds[@]}"
|
||||
echo "TARGS:${alt_targets[@]}"
|
||||
"""
|
||||
|
||||
|
||||
def test_new_template(runner, yadm):
|
||||
"""Test new template"""
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
{INIT_VARS}
|
||||
record_template "file_one" "cmd_one" "targ_one"
|
||||
record_template "file_two" "cmd_two" "targ_two"
|
||||
record_template "file_three" "cmd_three" "targ_three"
|
||||
{REPORT_RESULTS}
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert 'SIZE:3\n' in run.out
|
||||
assert 'FILENAMES:file_one file_two file_three\n' in run.out
|
||||
assert 'CMDS:cmd_one cmd_two cmd_three\n' in run.out
|
||||
assert 'TARGS:targ_one targ_two targ_three\n' in run.out
|
||||
|
||||
|
||||
def test_existing_template(runner, yadm):
|
||||
"""Overwrite existing templates"""
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
{INIT_VARS}
|
||||
alt_filenames=("testfile")
|
||||
alt_template_cmds=("existing_cmd")
|
||||
alt_targets=("existing_targ")
|
||||
record_template "testfile" "new_cmd" "new_targ"
|
||||
{REPORT_RESULTS}
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert 'SIZE:1\n' in run.out
|
||||
assert 'FILENAMES:testfile\n' in run.out
|
||||
assert 'CMDS:new_cmd\n' in run.out
|
||||
assert 'TARGS:new_targ\n' in run.out
|
@ -0,0 +1,229 @@
|
||||
"""Unit tests: score_file"""
|
||||
import pytest
|
||||
|
||||
CONDITION = {
|
||||
'default': {
|
||||
'labels': ['default'],
|
||||
'modifier': 0,
|
||||
},
|
||||
'system': {
|
||||
'labels': ['o', 'os'],
|
||||
'modifier': 1,
|
||||
},
|
||||
'class': {
|
||||
'labels': ['c', 'class'],
|
||||
'modifier': 2,
|
||||
},
|
||||
'hostname': {
|
||||
'labels': ['h', 'hostname'],
|
||||
'modifier': 4,
|
||||
},
|
||||
'user': {
|
||||
'labels': ['u', 'user'],
|
||||
'modifier': 8,
|
||||
},
|
||||
}
|
||||
TEMPLATE_LABELS = ['t', 'template', 'yadm']
|
||||
|
||||
|
||||
def calculate_score(filename):
|
||||
"""Calculate the expected score"""
|
||||
# pylint: disable=too-many-branches
|
||||
score = 0
|
||||
|
||||
_, conditions = filename.split('##', 1)
|
||||
|
||||
for condition in conditions.split(','):
|
||||
label = condition
|
||||
value = None
|
||||
if '.' in condition:
|
||||
label, value = condition.split('.', 1)
|
||||
if label in CONDITION['default']['labels']:
|
||||
score += 1000
|
||||
elif label in CONDITION['system']['labels']:
|
||||
if value == 'testsystem':
|
||||
score += 1000 + CONDITION['system']['modifier']
|
||||
else:
|
||||
return 0
|
||||
elif label in CONDITION['class']['labels']:
|
||||
if value == 'testclass':
|
||||
score += 1000 + CONDITION['class']['modifier']
|
||||
else:
|
||||
return 0
|
||||
elif label in CONDITION['hostname']['labels']:
|
||||
if value == 'testhost':
|
||||
score += 1000 + CONDITION['hostname']['modifier']
|
||||
else:
|
||||
return 0
|
||||
elif label in CONDITION['user']['labels']:
|
||||
if value == 'testuser':
|
||||
score += 1000 + CONDITION['user']['modifier']
|
||||
else:
|
||||
return 0
|
||||
elif label in TEMPLATE_LABELS:
|
||||
return 0
|
||||
return score
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
'default', ['default', None], ids=['default', 'no-default'])
|
||||
@pytest.mark.parametrize(
|
||||
'system', ['system', None], ids=['system', 'no-system'])
|
||||
@pytest.mark.parametrize(
|
||||
'cla', ['class', None], ids=['class', 'no-class'])
|
||||
@pytest.mark.parametrize(
|
||||
'host', ['hostname', None], ids=['hostname', 'no-host'])
|
||||
@pytest.mark.parametrize(
|
||||
'user', ['user', None], ids=['user', 'no-user'])
|
||||
def test_score_values(
|
||||
runner, yadm, default, system, cla, host, user):
|
||||
"""Test score results"""
|
||||
# pylint: disable=too-many-branches
|
||||
local_class = 'testclass'
|
||||
local_system = 'testsystem'
|
||||
local_host = 'testhost'
|
||||
local_user = 'testuser'
|
||||
filenames = {'filename##': 0}
|
||||
|
||||
if default:
|
||||
for filename in list(filenames):
|
||||
for label in CONDITION[default]['labels']:
|
||||
newfile = filename
|
||||
if not newfile.endswith('##'):
|
||||
newfile += ','
|
||||
newfile += label
|
||||
filenames[newfile] = calculate_score(newfile)
|
||||
if system:
|
||||
for filename in list(filenames):
|
||||
for match in [True, False]:
|
||||
for label in CONDITION[system]['labels']:
|
||||
newfile = filename
|
||||
if not newfile.endswith('##'):
|
||||
newfile += ','
|
||||
newfile += '.'.join([
|
||||
label,
|
||||
local_system if match else 'badsys'
|
||||
])
|
||||
filenames[newfile] = calculate_score(newfile)
|
||||
if cla:
|
||||
for filename in list(filenames):
|
||||
for match in [True, False]:
|
||||
for label in CONDITION[cla]['labels']:
|
||||
newfile = filename
|
||||
if not newfile.endswith('##'):
|
||||
newfile += ','
|
||||
newfile += '.'.join([
|
||||
label,
|
||||
local_class if match else 'badclass'
|
||||
])
|
||||
filenames[newfile] = calculate_score(newfile)
|
||||
if host:
|
||||
for filename in list(filenames):
|
||||
for match in [True, False]:
|
||||
for label in CONDITION[host]['labels']:
|
||||
newfile = filename
|
||||
if not newfile.endswith('##'):
|
||||
newfile += ','
|
||||
newfile += '.'.join([
|
||||
label,
|
||||
local_host if match else 'badhost'
|
||||
])
|
||||
filenames[newfile] = calculate_score(newfile)
|
||||
if user:
|
||||
for filename in list(filenames):
|
||||
for match in [True, False]:
|
||||
for label in CONDITION[user]['labels']:
|
||||
newfile = filename
|
||||
if not newfile.endswith('##'):
|
||||
newfile += ','
|
||||
newfile += '.'.join([
|
||||
label,
|
||||
local_user if match else 'baduser'
|
||||
])
|
||||
filenames[newfile] = calculate_score(newfile)
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
score=0
|
||||
local_class={local_class}
|
||||
local_system={local_system}
|
||||
local_host={local_host}
|
||||
local_user={local_user}
|
||||
"""
|
||||
expected = ''
|
||||
for filename in filenames:
|
||||
script += f"""
|
||||
score_file "{filename}"
|
||||
echo "{filename}"
|
||||
echo "$score"
|
||||
"""
|
||||
expected += filename + '\n'
|
||||
expected += str(filenames[filename]) + '\n'
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert run.out == expected
|
||||
|
||||
|
||||
def test_score_values_templates(runner, yadm):
|
||||
"""Test score results"""
|
||||
local_class = 'testclass'
|
||||
local_system = 'testsystem'
|
||||
local_host = 'testhost'
|
||||
local_user = 'testuser'
|
||||
filenames = {'filename##': 0}
|
||||
|
||||
for filename in list(filenames):
|
||||
for label in TEMPLATE_LABELS:
|
||||
newfile = filename
|
||||
if not newfile.endswith('##'):
|
||||
newfile += ','
|
||||
newfile += '.'.join([label, 'testtemplate'])
|
||||
filenames[newfile] = calculate_score(newfile)
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
score=0
|
||||
local_class={local_class}
|
||||
local_system={local_system}
|
||||
local_host={local_host}
|
||||
local_user={local_user}
|
||||
"""
|
||||
expected = ''
|
||||
for filename in filenames:
|
||||
script += f"""
|
||||
score_file "{filename}"
|
||||
echo "{filename}"
|
||||
echo "$score"
|
||||
"""
|
||||
expected += filename + '\n'
|
||||
expected += str(filenames[filename]) + '\n'
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert run.out == expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
'cmd_generated',
|
||||
[True, False],
|
||||
ids=['supported-template', 'unsupported-template'])
|
||||
def test_template_recording(runner, yadm, cmd_generated):
|
||||
"""Template should be recorded if choose_template_cmd outputs a command"""
|
||||
|
||||
mock = 'function choose_template_cmd() { return; }'
|
||||
expected = ''
|
||||
if cmd_generated:
|
||||
mock = 'function choose_template_cmd() { echo "test_cmd"; }'
|
||||
expected = 'template recorded'
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
function record_template() {{ echo "template recorded"; }}
|
||||
{mock}
|
||||
score_file "testfile##template.kind"
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert run.out.rstrip() == expected
|
@ -0,0 +1,98 @@
|
||||
"""Unit tests: template_builtin"""
|
||||
|
||||
# these values are also testing the handling of bizarre characters
|
||||
LOCAL_CLASS = "builtin_Test+@-!^Class"
|
||||
LOCAL_SYSTEM = "builtin_Test+@-!^System"
|
||||
LOCAL_HOST = "builtin_Test+@-!^Host"
|
||||
LOCAL_USER = "builtin_Test+@-!^User"
|
||||
LOCAL_DISTRO = "builtin_Test+@-!^Distro"
|
||||
TEMPLATE = f'''
|
||||
start of template
|
||||
builtin class = >YADM_CLASS<
|
||||
builtin os = >YADM_OS<
|
||||
builtin host = >YADM_HOSTNAME<
|
||||
builtin user = >YADM_USER<
|
||||
builtin distro = >YADM_DISTRO<
|
||||
YADM_IF CLASS="wrongclass1"
|
||||
wrong class 1
|
||||
YADM_END
|
||||
YADM_IF CLASS="{LOCAL_CLASS}"
|
||||
Included section for class = YADM_CLASS (YADM_CLASS repeated)
|
||||
YADM_END
|
||||
YADM_IF CLASS="wrongclass2"
|
||||
wrong class 2
|
||||
YADM_END
|
||||
YADM_IF OS="wrongos1"
|
||||
wrong os 1
|
||||
YADM_END
|
||||
YADM_IF OS="{LOCAL_SYSTEM}"
|
||||
Included section for os = YADM_OS (YADM_OS repeated)
|
||||
YADM_END
|
||||
YADM_IF OS="wrongos2"
|
||||
wrong os 2
|
||||
YADM_END
|
||||
YADM_IF HOSTNAME="wronghost1"
|
||||
wrong host 1
|
||||
YADM_END
|
||||
YADM_IF HOSTNAME="{LOCAL_HOST}"
|
||||
Included section for host = YADM_HOSTNAME (YADM_HOSTNAME repeated)
|
||||
YADM_END
|
||||
YADM_IF HOSTNAME="wronghost2"
|
||||
wrong host 2
|
||||
YADM_END
|
||||
YADM_IF USER="wronguser1"
|
||||
wrong user 1
|
||||
YADM_END
|
||||
YADM_IF USER="{LOCAL_USER}"
|
||||
Included section for user = YADM_USER (YADM_USER repeated)
|
||||
YADM_END
|
||||
YADM_IF USER="wronguser2"
|
||||
wrong user 2
|
||||
YADM_END
|
||||
YADM_IF DISTRO="wrongdistro1"
|
||||
wrong distro 1
|
||||
YADM_END
|
||||
YADM_IF DISTRO="{LOCAL_DISTRO}"
|
||||
Included section for distro = YADM_DISTRO (YADM_DISTRO repeated)
|
||||
YADM_END
|
||||
YADM_IF DISTRO="wrongdistro2"
|
||||
wrong distro 2
|
||||
YADM_END
|
||||
end of template
|
||||
'''
|
||||
EXPECTED = f'''
|
||||
start of template
|
||||
builtin class = >{LOCAL_CLASS}<
|
||||
builtin os = >{LOCAL_SYSTEM}<
|
||||
builtin host = >{LOCAL_HOST}<
|
||||
builtin user = >{LOCAL_USER}<
|
||||
builtin distro = >{LOCAL_DISTRO}<
|
||||
Included section for class = {LOCAL_CLASS} ({LOCAL_CLASS} repeated)
|
||||
Included section for os = {LOCAL_SYSTEM} ({LOCAL_SYSTEM} repeated)
|
||||
Included section for host = {LOCAL_HOST} ({LOCAL_HOST} repeated)
|
||||
Included section for user = {LOCAL_USER} ({LOCAL_USER} repeated)
|
||||
Included section for distro = {LOCAL_DISTRO} ({LOCAL_DISTRO} repeated)
|
||||
end of template
|
||||
'''
|
||||
|
||||
|
||||
def test_template_builtin(runner, yadm, tmpdir):
|
||||
"""Test template_builtin"""
|
||||
|
||||
input_file = tmpdir.join('input')
|
||||
input_file.write(TEMPLATE, ensure=True)
|
||||
output_file = tmpdir.join('output')
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
local_class="{LOCAL_CLASS}"
|
||||
local_system="{LOCAL_SYSTEM}"
|
||||
local_host="{LOCAL_HOST}"
|
||||
local_user="{LOCAL_USER}"
|
||||
local_distro="{LOCAL_DISTRO}"
|
||||
template_builtin "{input_file}" "{output_file}"
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert output_file.read() == EXPECTED
|
@ -0,0 +1,99 @@
|
||||
"""Unit tests: template_j2cli & template_envtpl"""
|
||||
import pytest
|
||||
|
||||
LOCAL_CLASS = "j2_Test+@-!^Class"
|
||||
LOCAL_SYSTEM = "j2_Test+@-!^System"
|
||||
LOCAL_HOST = "j2_Test+@-!^Host"
|
||||
LOCAL_USER = "j2_Test+@-!^User"
|
||||
LOCAL_DISTRO = "j2_Test+@-!^Distro"
|
||||
TEMPLATE = f'''
|
||||
start of template
|
||||
j2 class = >{{{{YADM_CLASS}}}}<
|
||||
j2 os = >{{{{YADM_OS}}}}<
|
||||
j2 host = >{{{{YADM_HOSTNAME}}}}<
|
||||
j2 user = >{{{{YADM_USER}}}}<
|
||||
j2 distro = >{{{{YADM_DISTRO}}}}<
|
||||
{{%- if YADM_CLASS == "wrongclass1" %}}
|
||||
wrong class 1
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_CLASS == "{LOCAL_CLASS}" %}}
|
||||
Included section for class = {{{{YADM_CLASS}}}} ({{{{YADM_CLASS}}}} repeated)
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_CLASS == "wrongclass2" %}}
|
||||
wrong class 2
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_OS == "wrongos1" %}}
|
||||
wrong os 1
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_OS == "{LOCAL_SYSTEM}" %}}
|
||||
Included section for os = {{{{YADM_OS}}}} ({{{{YADM_OS}}}} repeated)
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_OS == "wrongos2" %}}
|
||||
wrong os 2
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_HOSTNAME == "wronghost1" %}}
|
||||
wrong host 1
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_HOSTNAME == "{LOCAL_HOST}" %}}
|
||||
Included section for host = {{{{YADM_HOSTNAME}}}} ({{{{YADM_HOSTNAME}}}} again)
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_HOSTNAME == "wronghost2" %}}
|
||||
wrong host 2
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_USER == "wronguser1" %}}
|
||||
wrong user 1
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_USER == "{LOCAL_USER}" %}}
|
||||
Included section for user = {{{{YADM_USER}}}} ({{{{YADM_USER}}}} repeated)
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_USER == "wronguser2" %}}
|
||||
wrong user 2
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_DISTRO == "wrongdistro1" %}}
|
||||
wrong distro 1
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_DISTRO == "{LOCAL_DISTRO}" %}}
|
||||
Included section for distro = {{{{YADM_DISTRO}}}} ({{{{YADM_DISTRO}}}} again)
|
||||
{{%- endif %}}
|
||||
{{%- if YADM_DISTRO == "wrongdistro2" %}}
|
||||
wrong distro 2
|
||||
{{%- endif %}}
|
||||
end of template
|
||||
'''
|
||||
EXPECTED = f'''
|
||||
start of template
|
||||
j2 class = >{LOCAL_CLASS}<
|
||||
j2 os = >{LOCAL_SYSTEM}<
|
||||
j2 host = >{LOCAL_HOST}<
|
||||
j2 user = >{LOCAL_USER}<
|
||||
j2 distro = >{LOCAL_DISTRO}<
|
||||
Included section for class = {LOCAL_CLASS} ({LOCAL_CLASS} repeated)
|
||||
Included section for os = {LOCAL_SYSTEM} ({LOCAL_SYSTEM} repeated)
|
||||
Included section for host = {LOCAL_HOST} ({LOCAL_HOST} again)
|
||||
Included section for user = {LOCAL_USER} ({LOCAL_USER} repeated)
|
||||
Included section for distro = {LOCAL_DISTRO} ({LOCAL_DISTRO} again)
|
||||
end of template
|
||||
'''
|
||||
|
||||
|
||||
@pytest.mark.parametrize('processor', ('j2cli', 'envtpl'))
|
||||
def test_template_j2(runner, yadm, tmpdir, processor):
|
||||
"""Test processing by j2cli & envtpl"""
|
||||
|
||||
input_file = tmpdir.join('input')
|
||||
input_file.write(TEMPLATE, ensure=True)
|
||||
output_file = tmpdir.join('output')
|
||||
|
||||
script = f"""
|
||||
YADM_TEST=1 source {yadm}
|
||||
local_class="{LOCAL_CLASS}"
|
||||
local_system="{LOCAL_SYSTEM}"
|
||||
local_host="{LOCAL_HOST}"
|
||||
local_user="{LOCAL_USER}"
|
||||
local_distro="{LOCAL_DISTRO}"
|
||||
template_{processor} "{input_file}" "{output_file}"
|
||||
"""
|
||||
run = runner(command=['bash'], inp=script)
|
||||
assert run.success
|
||||
assert run.err == ''
|
||||
assert output_file.read() == EXPECTED
|
Loading…
Reference in new issue