def test_nested_subgroup_loop(self):
repo = Repository()
repo.add_group(Group("group1", {'subgroups': ["group2"]}))
repo.add_group(Group("group2", {'subgroups': ["group1"]}))
group = repo.get_group("group1")
with self.assertRaises(RepositoryError):
list(group.subgroups)
def test_generated_items(self, get_all_attrs_from_file):
def my_item_generator(node, bundle, item):
generated_items = {'files': {}}
if item.ITEM_TYPE_NAME == 'user':
file_path = "/home/{}/.screenrc".format(item.name)
generated_items['files'][file_path] = {
'content': "foo",
}
return generated_items
get_all_attrs_from_file.return_value = {
'item_generators': [
'test.generator',
],
'users': {
'jdoe': {},
},
}
repo = Repository()
repo.bundle_names = ["generatingbundle"]
repo.libs = MagicMock()
repo.libs.test.generator = my_item_generator
node = Node("node1", {'bundles': ["generatingbundle"]})
repo.add_node(node)
self.assertEqual(len(node.bundles[0]._generated_items), 1)
generated_item = node.bundles[0]._generated_items[0]
self.assertEqual(generated_item.id, "file:/home/jdoe/.screenrc")
def test_password_from_group(self):
n = Node("node1", {})
g = Group("group1", {'password': "******"})
r = Repository()
r.add_group(g)
r.add_node(n)
with patch('tests.unit.node_tests.Node.groups', new=(g,)):
self.assertEqual(n.password, "grouppasswd")
def test_apply(self, apply_items, NodeLock, ApplyResult):
repo = Repository()
n = Node("node1", {})
repo.add_node(n)
result = MagicMock()
ApplyResult.return_value = result
NodeLock.__enter__ = lambda x: x
NodeLock.__exit__ = lambda x: x
self.assertEqual(n.apply(), result)
self.assertEqual(apply_items.call_count, 1)
ApplyResult.assert_called_once()
def test_static_members(self):
repo = Repository()
node1 = Node("node1")
node2 = Node("node2")
repo.add_node(node1)
repo.add_node(node2)
group = Group("group1", {'members': ("node2", "node1")})
repo.add_group(group)
self.assertEqual(
set(group._nodes_from_static_members),
set((node1, node2)),
)
def test_no_members(self):
def _get_group(group_name):
group = MagicMock()
if group_name == "group1":
group.nodes = ["node1", "node2", "node3"]
if group_name == "group2":
group.nodes = ["node4"]
if group_name == "group3":
group.nodes = ["node2", "node3"]
return group
r = Repository()
r.get_group = _get_group
self.assertEqual(
r.nodes_in_all_groups(["group1", "group2", "group3"]),
[],
)
def test_static_subgroup_members(self, *args):
repo = Repository()
group1 = Group("group1", {'subgroups': ("group2",)})
node3 = Node("node3")
node4 = Node("node4")
repo.add_group(group1)
repo.add_group(Group("group2", {'members': ("node3", "node4")}))
repo.add_node(node3)
repo.add_node(node4)
repo.add_node(Node("node5"))
self.assertEqual(
set(group1._nodes_from_subgroups),
set((node3, node4)),
)
def test_repo_create(self, *args):
bundles = ("bundle1", "bundle2")
r = Repository.create(self.tmpdir)
for bundle in bundles:
mkdir(join(r.bundles_dir, bundle))
r.populate_from_path(self.tmpdir)
self.assertEqual(
set(r.bundle_names),
set(bundles),
)
def test_toml_conversion(tmpdir):
make_repo(
tmpdir,
nodes={
'node1': {
'os': 'ubuntu',
'metadata': {
"foo": {
"bar": "baz",
},
},
},
},
)
repo = Repository(tmpdir)
node = repo.get_node("node1")
node.toml_save()
assert get_file_contents(join(tmpdir, "nodes", "node1.toml")) == \
b"""os = "ubuntu"
def test_bundles(self):
repo = Repository()
repo.bundle_names = ("bundle1", "bundle2", "bundle3")
n = Node("node1", {})
repo.add_node(n)
g1 = Group("group1", {'bundles': ("bundle1", "bundle2")})
repo.add_group(g1)
g2 = Group("group2", {'bundles': ("bundle3",)})
repo.add_group(g2)
with patch('tests.unit.node_tests.Node.groups', new=(g1, g2)):
self.assertEqual(
tuple(names(n.bundles)),
("bundle1", "bundle2", "bundle3"),
)
def test_simple_subgroups(self):
repo = Repository()
repo.add_group(Group("group1", {'subgroups': ["group2", "group3"]}))
repo.add_group(Group("group2"))
repo.add_group(Group("group3"))
group = repo.get_group("group1")
self.assertEqual(list(names(group.subgroups)), ["group2", "group3"])
def test_nested_subgroups(self):
repo = Repository()
repo.add_group(Group("group1", {'subgroups': ["group2"]}))
repo.add_group(Group("group2", {'subgroups': ["group3"]}))
repo.add_group(Group("group3", {'subgroups': []}))
group = repo.get_group("group1")
self.assertEqual(
set(names(group.subgroups)),
set(["group2", "group3"]),
)
def test_with_custom(self):
r = Repository.create(self.tmpdir)
with open(join(r.items_dir, "good1.py"), 'w') as f:
f.write("from bundlewrap.items import Item\n"
"class GoodTestItem(Item): bad = False\n")
with open(join(r.items_dir, "_bad1.py"), 'w') as f:
f.write("from bundlewrap.items import Item\n"
"class BadTestItem(Item): bad = True\n")
with open(join(r.items_dir, "bad2.py"), 'w') as f:
f.write("from bundlewrap.items import Item\n"
"class _BadTestItem(Item): bad = True\n")
r.populate_from_path(self.tmpdir)
self.assertGreater(len(r.item_classes), 0)
for cls in r.item_classes:
if hasattr(cls, 'bad'):
self.assertFalse(cls.bad)
self.assertTrue(issubclass(cls, Item))
def main():
io.activate()
try:
repo = Repository("")
except NoSuchRepository:
io.stderr("{} Not inside a bundlewrap repository".format(red("!")))
sys.exit(1)
my_path = pathlib.Path(__file__).parent.absolute()
relpath = my_path.relative_to(repo.path)
if not str(relpath).startswith("collections/"):
io.stderr(
"{} Collection should be installed to <repo>/collections".format(
yellow("!")))
sys.exit(1)
install_dir(my_path / "hooks", repo.hooks_dir)
install_dir(my_path / "libs", repo.libs_dir)
install_dir(my_path / "items", repo.items_dir)
def test_pattern_members(self, *args):
repo = Repository()
repo.add_node(Node("node1"))
repo.add_node(Node("node2"))
group = Group("all", { 'member_patterns': (r".*",) })
repo.add_group(group)
self.assertEqual(
list(names(group.nodes)),
["node1", "node2"],
)
group2 = Group("group2", { 'member_patterns': (r".*2",)} )
repo.add_group(group2)
self.assertEqual(
list(names(group2.nodes)),
["node2"],
)
def test_password_from_repo(self):
n = Node("node1", {})
repo = Repository()
repo.password = "******"
repo.add_node(n)
self.assertEqual(n.password, "repopasswd")
from bundlewrap.repo import Repository
import os
dir_path = os.path.dirname(os.path.realpath(__file__))
repo = Repository(dir_path)
def generate():
key = input("Enter the desired key: ")
while True:
unencrypted = input("Please enter the unencrypted PW: ")
pw = repo.vault.encrypt(unencrypted, key=key)
print(pw)
pass
generate()
def test_no_subgroups(self):
repo = Repository()
repo.add_group(Group("group1", {'subgroups': []}))
group = repo.get_group("group1")
self.assertEqual(list(names(group.subgroups)), [])
