def test_metadatapy(tmpdir):
make_repo(
tmpdir,
bundles={"test": {}},
nodes={
"node1": {
'bundles': ["test"],
'metadata': {"foo": "bar"},
},
},
)
with open(join(str(tmpdir), "bundles", "test", "metadata.py"), 'w') as f:
f.write(
"""@metadata_processor
def foo(metadata):
metadata["baz"] = node.name
return metadata, DONE
""")
stdout, stderr, rcode = run("bw metadata node1", path=str(tmpdir))
assert loads(stdout.decode()) == {
"baz": "node1",
"foo": "bar",
}
assert stderr == b""
assert rcode == 0
def test_merge(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'metadata': {
"foo": {
"bar": "baz",
},
},
},
},
groups={
"group1": {
'members': ["node1"],
'metadata': {
"ding": 5,
"foo": {
"bar": "ZAB",
"baz": "bar",
},
},
},
},
)
stdout, stderr, rcode = run("bw metadata node1", path=str(tmpdir))
assert loads(stdout.decode()) == {
"ding": 5,
"foo": {
"bar": "baz",
"baz": "bar",
},
}
assert stderr == b""
assert rcode == 0
def test_empty_verify(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'files': {
join(str(tmpdir), "foo"): {
'content_type': 'any',
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
with open(join(str(tmpdir), "foo"), 'w') as f:
f.write("test")
stdout, stderr, rcode = run("bw verify localhost", path=str(tmpdir))
assert rcode == 0
def test_precedes_action(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'actions': {
"action1": {
'command': "echo 1 > {}".format(join(str(tmpdir), "file")),
'precedes': ["action:action2"],
'triggered': True,
},
"action2": {
'command': "echo 2 >> {}".format(join(str(tmpdir), "file")),
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
run("bw apply localhost", path=str(tmpdir))
with open(join(str(tmpdir), "file")) as f:
content = f.read()
assert content == "1\n2\n"
def test_precedes_unless4(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'files': {
join(str(tmpdir), "file"): {
'content': "1\n",
'triggered': True,
'precedes': ["action:action3"],
},
},
'actions': {
"action2": {
'command': "false",
'needs': ["file:{}".format(join(str(tmpdir), "file"))],
},
"action3": {
'command': "echo 3 >> {}".format(join(str(tmpdir), "file")),
'needs': ["action:action2"],
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
run("bw apply localhost", path=str(tmpdir))
with open(join(str(tmpdir), "file")) as f:
content = f.read()
assert content == "1\n"
def test_deterministic(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1"],
},
},
bundles={
"bundle1": {
'files': {
"/test": {
'content': "${node.name}",
'group': None, # BSD has a different default and we don't want to
# deal with that here
},
},
},
},
)
hashes = set()
for i in range(3):
stdout, stderr, rcode = run("bw hash", path=str(tmpdir))
hashes.add(stdout.strip())
assert len(hashes) == 1
assert hashes.pop() == b"2203e7acc35608bbff471c023b7b7498e5b385d9"
def test_fault_unavailable_multiple(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1"],
},
},
bundles={
"bundle1": {
'files': {
"/test": {
'content': "föö",
},
"/testdir/test3": {
'content': "${repo.vault.password_for('test', key='404')}",
'content_type': 'mako',
},
},
},
},
)
stdout, stderr, rcode = run("bw items -w itemprev node1", path=str(tmpdir))
assert rcode == 0
assert tmpdir.join("itemprev/test").exists()
assert not tmpdir.join("itemprev/testdir/test3").exists()
def test_circular_dep_indirect(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1"],
},
},
bundles={
"bundle1": {
"pkg_apt": {
"foo": {
'needs': ["pkg_apt:bar"],
},
"bar": {
'needs': ["pkg_apt:baz"],
},
"baz": {
'needs': ["pkg_apt:foo"],
},
},
},
},
)
assert run("bw test -I", path=str(tmpdir))[2] == 1
def test_secret_identifier_twice(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1"],
},
"node2": {
'bundles': ["bundle1"],
},
},
bundles={
"bundle1": {
'files': {
"/test": {
'content': "${repo.vault.password_for('testing')}",
'content_type': 'mako',
},
},
},
},
)
assert run("bw test -s ''", path=str(tmpdir))[2] == 0
assert run("bw test -s 'test'", path=str(tmpdir))[2] == 0
assert run("bw test -s 'test,foo'", path=str(tmpdir))[2] == 0
def test_groups(tmpdir):
make_repo(
tmpdir,
groups={
"group1": {
'members': ["node2"],
},
"group2": {
'members': ["node1"],
},
"group3": {
'subgroup_patterns': ["p2"],
},
"group4": {
'subgroups': ["group1"],
},
},
nodes={
"node1": {},
"node2": {},
},
)
stdout, stderr, rcode = run("bw nodes --groups", path=str(tmpdir))
assert stdout.decode().strip().split("\n") == [
"node1: group2, group3",
"node2: group1, group4",
]
assert stderr == b""
assert rcode == 0
def test_only_bundle_with_dep(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'files': {
join(str(tmpdir), "foo"): {
'content_type': 'any',
'needs': ["file:" + join(str(tmpdir), "bar")],
},
},
},
"test2": {
'files': {
join(str(tmpdir), "bar"): {
'content_type': 'any',
},
join(str(tmpdir), "baz"): {
'content_type': 'any',
},
},
},
},
nodes={
"localhost": {
'bundles': ["test", "test2"],
'os': host_os(),
},
},
)
run("bw apply -o bundle:test localhost", path=str(tmpdir))
assert exists(join(str(tmpdir), "foo"))
assert exists(join(str(tmpdir), "bar"))
assert not exists(join(str(tmpdir), "baz"))
def test_fault_content_error(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
with open(join(str(tmpdir), "bundles", "test", "items.py"), 'w') as f:
f.write("""
files = {{
"{}": {{
'content': repo.vault.password_for("test", key='unavailable'),
'error_on_missing_fault': True,
}},
}}
""".format(join(str(tmpdir), "secret")))
stdout, stderr, rcode = run("bw -d apply localhost", path=str(tmpdir))
print(stdout)
assert rcode == 1
def test_group_members_partial_metadata(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'metadata': {'foo': 1},
},
"node2": {},
},
)
with open(join(str(tmpdir), "groups.py"), 'w') as f:
f.write("""
groups = {
"group1": {
'members_add': lambda node: node.metadata.get('foo') == 1,
},
"group2": {
'members': ["node2"],
'metadata': {'foo': 1},
},
}
""")
stdout, stderr, rcode = run("bw nodes -a node1 | grep \tgroup | cut -f 3", path=str(tmpdir))
assert stdout == b"group1\n"
assert stderr == b""
assert rcode == 0
stdout, stderr, rcode = run("bw nodes -a node2 | grep \tgroup | cut -f 3", path=str(tmpdir))
assert stdout == b"group2\n"
assert stderr == b""
assert rcode == 0
def test_b64encode_fault(tmpdir):
make_repo(tmpdir)
stdout, stderr, rcode = run("bw debug -c 'print(repo.vault.password_for(\"testing\").b64encode())'", path=str(tmpdir))
assert stdout == b"ZmFDVFQ3NmthZ3REdVpFNXdub2lEMUN4aEdLbWJnaVg=\n"
assert stderr == b""
assert rcode == 0
def test_human_password(tmpdir):
make_repo(tmpdir)
stdout, stderr, rcode = run("bw debug -c 'print(repo.vault.human_password_for(\"hello world\"))'", path=str(tmpdir))
assert stdout == b"Xaint-Heep-Pier-Tikl-76\n"
assert stderr == b""
assert rcode == 0
def test_format_password(tmpdir):
make_repo(tmpdir)
stdout, stderr, rcode = run("bw debug -c 'print(repo.vault.password_for(\"testing\").format_into(\"format: {}\"))'", path=str(tmpdir))
assert stdout == b"format: faCTT76kagtDuZE5wnoiD1CxhGKmbgiX\n"
assert stderr == b""
assert rcode == 0
def test_encrypt_file_base64(tmpdir):
make_repo(tmpdir)
source_file = join(str(tmpdir), "data", "source")
with open(source_file, 'wb') as f:
f.write("öhai".encode('latin-1'))
stdout, stderr, rcode = run(
"bw debug -c 'repo.vault.encrypt_file(\"{}\", \"{}\")'".format(
source_file,
"encrypted",
),
path=str(tmpdir),
)
assert stderr == b""
assert rcode == 0
stdout, stderr, rcode = run(
"bw debug -c 'print(repo.vault.decrypt_file_as_base64(\"{}\"))'".format(
"encrypted",
),
path=str(tmpdir),
)
assert b64decode(stdout.decode('utf-8')) == "öhai".encode('latin-1')
assert stderr == b""
assert rcode == 0
def test_nondeterministic(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1"],
},
},
bundles={
"bundle1": {
'files': {
"/test": {
'content_type': 'mako',
'content': "<% import random %>${random.randint(1, 9999)}",
},
},
},
},
)
hashes = set()
for i in range(3):
stdout, stderr, rcode = run("bw hash", path=str(tmpdir))
hashes.add(stdout.strip())
assert len(hashes) > 1
def test_any_content_exists(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'files': {
join(str(tmpdir), "foo"): {
'content_type': 'any',
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
with open(join(str(tmpdir), "foo"), 'wb') as f:
f.write(b"existing content")
run("bw apply localhost", path=str(tmpdir))
with open(join(str(tmpdir), "foo"), 'rb') as f:
content = f.read()
assert content == b"existing content"
def test_fault_content_mako_metadata(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'files': {
join(str(tmpdir), "secret"): {
'content': "${node.metadata['secret']}",
'content_type': 'mako',
},
},
},
},
)
with open(join(str(tmpdir), "nodes.py"), 'w') as f:
f.write("""
nodes = {{
"localhost": {{
'bundles': ["test"],
'metadata': {{'secret': vault.password_for("test")}},
'os': "{}",
}},
}}
""".format(host_os()))
run("bw apply localhost", path=str(tmpdir))
with open(join(str(tmpdir), "secret")) as f:
content = f.read()
assert content == "sQDdTXu5OmCki8gdGgYdfTxooevckXcB"
def test_group_members_remove_bundle(tmpdir):
make_repo(
tmpdir,
bundles={
"bundle1": {},
"bundle2": {},
},
nodes={
"node1": {},
"node2": {},
},
)
with open(join(str(tmpdir), "groups.py"), 'w') as f:
f.write("""
groups = {
"group1": {
'bundles': ["bundle1"],
'members': ["node1", "node2"],
},
"group2": {
'bundles': ["bundle1", "bundle2"],
'members': ["node1", "node2"],
'members_remove': lambda node: node.name == "node2",
},
}
""")
stdout, stderr, rcode = run("bw nodes -a node1 | grep \tbundle | cut -f 3", path=str(tmpdir))
assert stdout == b"bundle1\nbundle2\n"
assert stderr == b""
assert rcode == 0
stdout, stderr, rcode = run("bw nodes -a node2 | grep \tbundle | cut -f 3", path=str(tmpdir))
assert stdout == b"bundle1\n"
assert stderr == b""
assert rcode == 0
def test_fault_content(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
with open(join(str(tmpdir), "bundles", "test", "items.py"), 'w') as f:
f.write("""
files = {{
"{}": {{
'content': repo.vault.password_for("test"),
}},
}}
""".format(join(str(tmpdir), "secret")))
run("bw apply localhost", path=str(tmpdir))
with open(join(str(tmpdir), "secret")) as f:
content = f.read()
assert content == "sQDdTXu5OmCki8gdGgYdfTxooevckXcB"
def test_inline(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1", "bundle2"],
},
"node2": {
'bundles': ["bundle1"],
},
},
bundles={
"bundle1": {},
"bundle2": {},
},
)
stdout, stderr, rcode = run("bw nodes -ai | grep '\tbundle' | grep bundle2 | cut -f 1", path=str(tmpdir))
assert stdout == b"node1\n"
assert stderr == b""
assert rcode == 0
stdout, stderr, rcode = run("bw nodes -ai | grep '\tbundle' | grep -v bundle2 | cut -f 1", path=str(tmpdir))
assert stdout == b"node2\n"
assert stderr == b""
assert rcode == 0
def test_fault_content_jinja2(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'files': {
join(str(tmpdir), "secret"): {
'content': "{{ repo.vault.password_for('test') }}",
'content_type': 'jinja2',
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
run("bw apply localhost", path=str(tmpdir))
with open(join(str(tmpdir), "secret")) as f:
content = f.read()
assert content == "sQDdTXu5OmCki8gdGgYdfTxooevckXcB"
def test_add_lock_apply_remove(tmpdir):
make_repo(
tmpdir,
nodes={
"localhost": {
'bundles': ["bundle1"],
'os': host_os(),
},
},
bundles={
"bundle1": {
'files': {
"/tmp/bw_test_lock_add": {
'content': "foo",
},
},
},
},
)
run("rm -f /tmp/bw_test_lock_add")
stdout, stderr, rcode = run("BW_IDENTITY=jdoe bw lock add -c höhöhö -e 1m -i file:/tmp/bw_test_lock_add localhost", path=str(tmpdir))
assert rcode == 0
lock_id = get_lock_id(stdout.decode('utf-8'))
assert len(lock_id) == 4
stdout, stderr, rcode = run("bw apply localhost", path=str(tmpdir))
assert rcode == 0
stdout, stderr, rcode = run("cat /tmp/bw_test_lock_add", path=str(tmpdir))
assert rcode != 0
stdout, stderr, rcode = run("bw lock remove localhost {}".format(lock_id), path=str(tmpdir))
assert rcode == 0
def test_group_metadata_collision_subgroups(tmpdir):
make_repo(
tmpdir,
nodes={"node1": {}},
groups={
"group1": {
'members': ["node1"],
'metadata': {
'foo': {
'baz': 1,
},
'bar': 2,
},
},
"group2": {
'metadata': {
'foo': {
'baz': 3,
},
'snap': 4,
},
'subgroups': ["group1", "group3"],
},
"group3": {
'members': ["node1"],
},
},
)
assert run("bw test -M", path=str(tmpdir))[2] == 0
def test_apply(tmpdir):
make_repo(
tmpdir,
bundles={
"bundle1": {
'files': {
join(str(tmpdir), "test"): {
'content': "test",
},
},
},
},
groups={
"adhoc-localhost": {
'bundles': ["bundle1"],
'member_patterns': ["localhost"],
'os': host_os(),
},
},
)
assert not exists(join(str(tmpdir), "test"))
stdout, stderr, rcode = run("bw -A apply localhost", path=str(tmpdir))
assert rcode == 0
assert exists(join(str(tmpdir), "test"))
def test_binary_template_content(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'files': {
join(str(tmpdir), "foo.bin"): {
'encoding': 'latin-1',
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
with open(join(str(tmpdir), "bundles", "test", "files", "foo.bin"), 'wb') as f:
f.write("ö".encode('utf-8'))
run("bw apply localhost", path=str(tmpdir))
with open(join(str(tmpdir), "foo.bin"), 'rb') as f:
content = f.read()
assert content.decode('latin-1') == "ö"
def test_fix_dir_target(tmpdir):
mkdir(join(str(tmpdir), "dir1"))
mkdir(join(str(tmpdir), "dir2"))
symlink(join(str(tmpdir), "dir1"), join(str(tmpdir), "link"))
make_repo(
tmpdir,
bundles={
"test": {
'symlinks': {
join(str(tmpdir), "link"): {
'target': join(str(tmpdir), "dir2"),
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
stdout, stderr, rcode = run("bw apply localhost", path=str(tmpdir))
assert rcode == 0
assert readlink(join(str(tmpdir), "link")) == join(str(tmpdir), "dir2")
def test_multiple_file_preview(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1"],
},
},
bundles={
"bundle1": {
'files': {
"/test": {
'content': "föö",
},
"/testdir/test2": {
'content': "bar",
},
},
},
},
)
stdout, stderr, rcode = run("bw items -w itemprev node1", path=str(tmpdir))
assert rcode == 0
assert tmpdir.join("itemprev/test").exists()
assert tmpdir.join("itemprev/testdir/test2").exists()
def test_table_no_key(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {},
},
)
stdout, stderr, rcode = run("bw metadata --table node1", path=str(tmpdir))
assert rcode == 1
def test_bundle_not_found(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1"],
},
},
)
assert run("bw test", path=str(tmpdir))[2] == 1
def test_faults_equality_password_for_mixed(tmpdir):
make_repo(tmpdir)
stdout, stderr, rcode = run(
"bw debug -c 'print(repo.vault.password_for(\"a\") == repo.vault.human_password_for(\"a\"))'",
path=str(tmpdir),
)
assert stdout == b"False\n"
assert stderr == b""
assert rcode == 0
def test_simple(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {'metadata': {"foo": "bar"}},
},
)
stdout, stderr, rcode = run("bw metadata node1", path=str(tmpdir))
assert loads(stdout.decode()) == {"foo": "bar"}
assert stderr == b""
assert rcode == 0
def test_encrypt_different_key_autodetect(tmpdir):
make_repo(tmpdir)
stdout, stderr, rcode = run("bw debug -c 'print(repo.vault.encrypt(\"test\", key=\"generate\"))'", path=str(tmpdir))
assert stderr == b""
assert rcode == 0
stdout, stderr, rcode = run("bw debug -c 'print(repo.vault.decrypt(\"{}\"))'".format(stdout.decode('utf-8').strip()), path=str(tmpdir))
assert stdout == b"test\n"
assert stderr == b""
assert rcode == 0
def test_empty(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {},
},
)
stdout, stderr, rcode = run("bw metadata node1", path=str(tmpdir))
assert stdout == b"{}\n"
assert stderr == b""
assert rcode == 0
def test_groups_repo(tmpdir):
make_repo(
tmpdir,
groups={
"group1": {},
"group2": {},
},
)
stdout, stderr, rcode = run("bw hash -g", path=str(tmpdir))
assert rcode == 0
assert stdout == b"479c737e191339e5fae20ac8a8903a75f6b91f4d\n"
def test_groups_repo_dict(tmpdir):
make_repo(
tmpdir,
groups={
"group1": {},
"group2": {},
},
)
stdout, stderr, rcode = run("bw hash -dg", path=str(tmpdir))
assert rcode == 0
assert stdout == b"group1\ngroup2\n"
def test_metadata_empty(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'metadata': {},
},
},
)
stdout, stderr, rcode = run("bw hash -m node1", path=str(tmpdir))
assert rcode == 0
assert stdout == b"bf21a9e8fbc5a3846fb05b4fa0859e0917b2202f\n"
def test_empty_group(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {'groups': {"group2"}},
},
groups={
"group1": {},
"group2": {},
},
)
assert run("bw test", path=str(tmpdir))[2] == 0
assert run("bw test -e", path=str(tmpdir))[2] == 1
def test_unknown_subgroup(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {'groups': {"group2"}},
},
groups={
"group1": {'subgroups': ["missing-group"]},
"group2": {},
},
)
assert run("bw test", path=str(tmpdir))[2] == 1
assert run("bw test group1", path=str(tmpdir))[2] == 1
assert run("bw test group2", path=str(tmpdir))[2] == 1
def test_other_node_metadata(tmpdir):
make_repo(
tmpdir,
bundles={"test": {}},
nodes={
"node1": {
'bundles': ["test"],
'metadata': {
'number': 47
},
},
"node2": {
'bundles': ["test"],
'metadata': {
'number': 42
},
},
"node3": {
'bundles': ["test"],
'metadata': {
'number': 23
},
},
},
)
with open(join(str(tmpdir), "bundles", "test", "metadata.py"), 'w') as f:
f.write("""
@metadata_reactor
def reactor1(metadata):
numbers = set()
for n in repo.nodes:
if n != node:
numbers.add(n.metadata.get('number'))
return {'other_numbers': numbers}
""")
stdout, stderr, rcode = run("bw metadata node1", path=str(tmpdir))
assert loads(stdout.decode()) == {
"number": 47,
"other_numbers": [23, 42],
}
stdout, stderr, rcode = run("bw metadata node2", path=str(tmpdir))
assert loads(stdout.decode()) == {
"number": 42,
"other_numbers": [23, 47],
}
stdout, stderr, rcode = run("bw metadata node3", path=str(tmpdir))
assert loads(stdout.decode()) == {
"number": 23,
"other_numbers": [42, 47],
}
def test_supergroups_redundant(tmpdir):
make_repo(
tmpdir,
groups={
"group1": {'subgroups': {"group2"}},
"group2": {'supergroups': {"group1"}},
"group3": {},
},
)
stdout, stderr, rcode = run("BW_TABLE_STYLE=grep bw groups group1", path=str(tmpdir))
assert b"group1" in stderr
assert b"group2" in stderr
assert b"group3" not in stderr
assert rcode == 1
def test_run_ok(tmpdir):
make_repo(
tmpdir,
nodes={
"localhost": {
'os': host_os(),
},
},
)
stdout, stderr, rcode = run("BW_TABLE_STYLE=grep bw run localhost true",
path=str(tmpdir))
assert rcode == 0
assert b"localhost\t0" in stdout
assert stderr == b""
def test_create(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'postgres_dbs': {
"bw-test1": {
'owner': "bw-test1",
},
},
'postgres_roles': {
"bw-test1": {
'superuser': True,
'password': '******',
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
stdout, stderr, rcode = run("bw apply localhost", path=str(tmpdir))
assert rcode == 0
stdout, stderr, rcode = run(
"bw items --state localhost postgres_db:bw-test1",
path=str(tmpdir))
assert rcode == 0
assert loads(stdout.decode()) == {'owner': "bw-test1"}
stdout, stderr, rcode = run(
"bw items --state localhost postgres_role:bw-test1",
path=str(tmpdir))
assert rcode == 0
assert loads(stdout.decode()) == {
'can_login': True,
'password_hash': "md5ecba3aec62c5aabf6480de6352182004",
'superuser': True,
}
stdout, stderr, rcode = run("dropdb bw-test1", path=str(tmpdir))
assert rcode == 0
stdout, stderr, rcode = run("dropuser bw-test1", path=str(tmpdir))
assert rcode == 0
def test_metadata_repo(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'metadata': {
'foo': 47,
},
},
},
)
stdout, stderr, rcode = run("bw hash -m", path=str(tmpdir))
assert rcode == 0
assert stdout == b"8c4a30eaa521c966c678d6e51070f6b3a34b7322\n"
def test_metadata_repo_dict(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'metadata': {
'foo': 47,
},
},
},
)
stdout, stderr, rcode = run("bw hash -md", path=str(tmpdir))
assert rcode == 0
assert stdout == b"node1\t223fb72805ecab20f92b463af65896303f997f1c\n"
def test_metadata_repo(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'metadata': {
'foo': 47,
},
},
},
)
stdout, stderr, rcode = run("bw hash -m", path=str(tmpdir))
assert rcode == 0
assert stdout == b"c0cc160ab1b6e71155cd4f65139bc7f66304d7f3\n"
def test_metadata_repo_dict(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'metadata': {
'foo': 47,
},
},
},
)
stdout, stderr, rcode = run("bw hash -md", path=str(tmpdir))
assert rcode == 0
assert stdout == b"node1\t013b3a8199695eb45c603ea4e0a910148d80e7ed\n"
def test_template_node_cascade(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'template_node': "node2"
},
"node2": {
'template_node': "node1"
},
},
)
stdout, stderr, rcode = run("BW_TABLE_STYLE=grep bw nodes node1 dummy",
path=str(tmpdir))
assert rcode == 1
def test_faults_equality_decrypt_file_as_base64(tmpdir):
make_repo(tmpdir)
source_file = join(str(tmpdir), "data", "source")
with open(source_file, 'w') as f:
f.write("foo")
stdout, stderr, rcode = run(
"bw debug -c 'repo.vault.encrypt_file(\"{}\", \"{}\")'".format(
source_file,
"enc_foo",
),
path=str(tmpdir),
)
assert stderr == b""
assert rcode == 0
source_file = join(str(tmpdir), "data", "source")
with open(source_file, 'w') as f:
f.write("bar")
stdout, stderr, rcode = run(
"bw debug -c 'repo.vault.encrypt_file(\"{}\", \"{}\")'".format(
source_file,
"enc_bar",
),
path=str(tmpdir),
)
assert stderr == b""
assert rcode == 0
stdout, stderr, rcode = run(
"bw debug -c 'print(repo.vault.decrypt_file_as_base64(\"{}\") == repo.vault.decrypt_file_as_base64(\"{}\"))'".format(
"enc_foo", "enc_foo",
),
path=str(tmpdir),
)
assert stdout == b"True\n"
assert stderr == b""
assert rcode == 0
stdout, stderr, rcode = run(
"bw debug -c 'print(repo.vault.decrypt_file_as_base64(\"{}\") == repo.vault.decrypt_file_as_base64(\"{}\"))'".format(
"enc_foo", "enc_bar",
),
path=str(tmpdir),
)
assert stdout == b"False\n"
assert stderr == b""
assert rcode == 0
def test_group_loop(tmpdir):
make_repo(
tmpdir,
groups={
"group1": {
'subgroups': ["group2"],
},
"group2": {
'subgroups': ["group3"],
},
"group3": {
'subgroups': ["group1"],
},
},
)
assert run("bw test -S", path=str(tmpdir))[2] == 1
def test_hostname(tmpdir):
make_repo(
tmpdir,
groups={"all": {
'members': ["node1"]
}},
nodes={"node1": {
'hostname': "node1.example.com"
}},
)
stdout, stderr, rcode = run(
"BW_TABLE_STYLE=grep bw nodes all hostname | cut -f 2",
path=str(tmpdir))
assert stdout == b"node1.example.com\n"
assert stderr == b""
assert rcode == 0
def test_group_members_remove(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'os': 'centos'
},
"node2": {
'os': 'debian'
},
"node3": {
'os': 'ubuntu'
},
"node4": {
'os': 'ubuntu'
},
},
)
with open(join(str(tmpdir), "groups.py"), 'w') as f:
f.write("""
groups = {
"group1": {
'members_add': lambda node: node.os == 'ubuntu',
},
"group2": {
'members_add': lambda node: node.os == 'ubuntu',
'members_remove': lambda node: node.name == "node3",
},
"group3": {
'members_add': lambda node: not node.in_group("group3"),
},
"group4": {
'subgroups': ["group3"],
'members_remove': lambda node: node.os == 'debian',
},
}
""")
stdout, stderr, rcode = run(
"BW_TABLE_STYLE=grep bw groups -i group1,group2,group3,group4 nodes",
path=str(tmpdir))
assert stdout == b"""group1\tnode3,node4
group2\tnode4
group3\tnode1,node2,node3,node4
group4\tnode1,node3,node4
"""
assert stderr == b""
assert rcode == 0
def test_metadatapy_merge_order(tmpdir):
make_repo(
tmpdir,
bundles={"test": {}},
nodes={
"node1": {
'bundles': ["test"],
'groups': {"group1"},
'metadata': {
"four": "node",
},
},
},
groups={
"group1": {
'metadata': {
"three": "group",
"four": "group",
},
},
},
)
with open(join(str(tmpdir), "bundles", "test", "metadata.py"), 'w') as f:
f.write("""defaults = {
"one": "defaults",
"two": "defaults",
"three": "defaults",
"four": "defaults",
}
@metadata_reactor
def foo_reactor(metadata):
return {
"two": "reactor",
"three": "reactor",
"four": "reactor",
}
""")
stdout, stderr, rcode = run("bw metadata node1", path=str(tmpdir))
assert loads(stdout.decode()) == {
"one": "defaults",
"two": "reactor",
"three": "group",
"four": "node",
}
assert stderr == b""
assert rcode == 0
def test_groups_node_dict(tmpdir):
make_repo(
tmpdir,
groups={
"group1": {'members': ["node1", "node2"]},
"group2": {'members': ["node3"]},
},
nodes={
"node1": {},
"node2": {},
"node3": {},
},
)
stdout, stderr, rcode = run("bw hash -dg node1", path=str(tmpdir))
assert rcode == 0
assert stdout == b"group1\n"
def test_purge(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'files': {
join(str(tmpdir), "purgedir", "managed_file"): {
'content': "content",
},
join(str(tmpdir), "purgedir", "subdir1", "managed_file"): {
'content': "content",
},
},
'directories': {
join(str(tmpdir), "purgedir"): {
'purge': True,
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
mkdir(join(str(tmpdir), "purgedir"))
mkdir(join(str(tmpdir), "purgedir", "subdir2"))
mkdir(join(str(tmpdir), "purgedir", "subdir3"))
with open(join(str(tmpdir), "purgedir", "unmanaged_file"), 'w') as f:
f.write("content")
with open(join(str(tmpdir), "purgedir", "subdir3", "unmanaged_file"),
'w') as f:
f.write("content")
run("bw apply localhost", path=str(tmpdir))
assert not exists(join(str(tmpdir), "purgedir", "unmanaged_file"))
assert not exists(
join(str(tmpdir), "purgedir", "subdir3", "unmanaged_file"))
assert not exists(join(str(tmpdir), "purgedir", "subdir2"))
assert exists(join(str(tmpdir), "purgedir", "subdir1", "managed_file"))
assert exists(join(str(tmpdir), "purgedir", "managed_file"))
def test_whole_node(tmpdir):
make_repo(
tmpdir,
nodes={
"node1": {
'bundles': ["bundle1", "bundle3"]
},
"node2": {
'bundles': ["bundle2", "bundle3"]
},
},
bundles={
"bundle1": {
'items': {
"files": {
"/tmp/foo": {
'content': "one",
},
},
},
},
"bundle2": {
'items': {
"files": {
"/tmp/foo": {
'content': "two",
},
},
},
},
"bundle3": {
'items': {
"files": {
"/tmp/bar": {
'content': "common",
},
},
},
},
},
)
stdout, stderr, rcode = run("bw diff node1 node2", path=str(tmpdir))
assert b"/tmp/foo" in stdout
assert b"/tmp/bar" not in stdout
assert stderr == b""
assert rcode == 0
def test_in_group(tmpdir):
make_repo(
tmpdir,
groups={
"group1": {
'members': ["node2"],
},
},
nodes={
"node1": {},
"node2": {},
},
)
stdout, stderr, rcode = run("bw nodes -g group1", path=str(tmpdir))
assert stdout == b"node2\n"
assert stderr == b""
assert rcode == 0
def test_purge_special_chars(tmpdir):
make_repo(
tmpdir,
bundles={
"test": {
'items': {
'files': {
join(str(tmpdir), "purgedir", "mänäged_file"): {
'content': "content",
},
join(str(tmpdir), "purgedir", "managed_`id`_file"): {
'content': "content",
},
},
'directories': {
join(str(tmpdir), "purgedir"): {
'purge': True,
},
},
},
},
},
nodes={
"localhost": {
'bundles': ["test"],
'os': host_os(),
},
},
)
mkdir(join(str(tmpdir), "purgedir"))
with open(join(str(tmpdir), "purgedir", "unmänäged_file"), 'w') as f:
f.write("content")
with open(join(str(tmpdir), "purgedir", "unmanaged_`uname`_file"), 'w') as f:
f.write("content")
with open(join(str(tmpdir), "purgedir", "unmanaged_:'_file"), 'w') as f:
f.write("content")
run("bw apply localhost", path=str(tmpdir))
assert not exists(join(str(tmpdir), "purgedir", "unmänäged_file"))
assert not exists(join(str(tmpdir), "purgedir", "unmanaged_`uname`_file"))
assert not exists(join(str(tmpdir), "purgedir", "unmanaged_:'_file"))
assert exists(join(str(tmpdir), "purgedir", "mänäged_file"))
assert exists(join(str(tmpdir), "purgedir", "managed_`id`_file"))
