def test_upload_folder_with_folder(self, mocked_fun):
updated = 200
created = 100
test_node = TreeNode(Node("CLIENT_NODE", self.folder_name,
Type.Folder, created, updated, self.path))
test_node.add_node(TreeNode(Node("CLIENT_NODE", self.file_name,
Type.Folder, created, updated, self.path)))
os_handler.upload_folder(test_node, self.path)
self.assertEqual(mocked_fun.call_count, 2)
def test_upload_folder_with_file(self, mocked_create, mocked_upload):
updated = 200
created = 100
test_node = TreeNode(Node("CLIENT_NODE", self.folder_name,
Type.Folder, created, updated, self.path))
test_node.add_node(TreeNode(Node("CLIENT_NODE", self.file_name,
Type.File, created, updated, self.path)))
os_handler.upload_folder(test_node, self.path)
mocked_upload.assert_called_once()
mocked_create.assert_called_once()
def test_download_folder_with_file(self, mock_1, mock_2, mock_3):
updated = 200
created = 100
test_node = TreeNode(Node("CLIENT_NODE", self.folder_name,
Type.Folder, created, updated, self.path))
test_node.add_node(TreeNode(Node("CLIENT_NODE", self.file_name,
Type.File, created, updated, self.path)))
x = os_handler.download_folder(test_node, self.path)
self.assertEqual(x, [True])
mock_1.assert_called_once()
mock_2.assert_called_once()
mock_3.assert_called_once()
def test_download_folder_with_folder(self):
created = 100
updated = 200
test_node = TreeNode(Node("CLIENT_NODE", self.folder_name,
Type.Folder, created, updated, self.path))
test_node.add_node(TreeNode(Node("CLIENT_NODE", self.folder_name,
Type.Folder, created, updated, self.path)))
x = os_handler.download_folder(test_node, self.path)
self.assertEqual(x, [])
folder_path = os.path.join(self.path, self.folder_name)
inner_folder_path = os.path.join(folder_path, self.folder_name)
self.assertEqual(os.path.exists(folder_path), False)
self.assertEqual(os.path.exists(inner_folder_path), False)
def get_tree_from_system(path: str,
root_name: str = "ROOT",
prev_node: TreeNode = None) -> TreeNode:
"""Funzione ricorsiva per costruire l'albero dato un path"""
parent_node = _build_tree_node(path, root_name)
for name in os.listdir(path):
if name not in black_list:
abs_path = os.path.join(path, name)
if os.path.isdir(abs_path):
get_tree_from_system(abs_path, name, parent_node)
else:
parent_node.add_node(_build_tree_node(abs_path, name))
if prev_node is not None:
prev_node.add_node(parent_node)
return parent_node
def test_check_node_in_nodelist(self):
updated = 200
created = 100
test_node = TreeNode(Node("ROOT", self.folder_name,
Type.Folder, created, updated, self.path))
test_node.add_node(TreeNode(Node("b", self.file_name,
Type.File, created, updated, self.path)))
sub_folder = TreeNode(Node("a", self.folder_name,
Type.Folder, created, updated, self.path))
sub_folder.add_node(TreeNode(Node("f", self.folder_name,
Type.File, created, updated, self.path)))
test_node.add_node(sub_folder)
res = os_handler.check_node_in_nodelist(test_node, ["a", "b"])
self.assertTrue(res)
res = os_handler.check_node_in_nodelist(test_node, ["d", "e"])
self.assertFalse(res)
res = os_handler.check_node_in_nodelist(test_node, ["f"])
self.assertTrue(res)
def test_add_node_exception(self) -> None:
root = TreeNode(self.files[0])
with self.assertRaises(ValueError):
root.add_node(TreeNode(self.files[1]))
class TestTreeNode(unittest.TestCase):
def setUp(self):
"""Metodo che viene chiamato prima di ogni metodo"""
self.files: list[Node] = [
Node("CLIENT_NODE", "Test", Type.File, 1000, 1022,
"root/file.txt"),
Node("CLIENT_NODE", "Test2", Type.File, 1000, 1024,
"root/file2.txt"),
Node("CLIENT_NODE", "Test3", Type.File, 1000, 1026,
"root/root2/file3.txt"),
]
self.folders: list[Node] = [
Node("CLIENT_NODE", "Test Folder", Type.Folder, 1000, 1022,
"root"),
Node("CLIENT_NODE", "Test Folder2", Type.Folder, 1000, 1025,
"root/root2"),
]
self.tree_node = TreeNode(self.folders[0])
self.tree_node.add_node(TreeNode(self.files[0]))
self.tree_node.add_node(TreeNode(self.files[1]))
self.tree_node_sub = TreeNode(self.folders[1])
self.tree_node_sub.add_node(TreeNode(self.files[2]))
self.tree_node.add_node(self.tree_node_sub)
def test_is_directory(self) -> None:
self.assertTrue(self.tree_node.is_directory())
self.assertFalse(self.tree_node._children[0].is_directory())
self.assertFalse(self.tree_node._children[1].is_directory())
self.assertTrue(self.tree_node._children[2].is_directory())
self.assertFalse(
self.tree_node._children[2]._children[0].is_directory())
def test_get_name(self) -> None:
tests = {
"Test Folder": self.tree_node.get_name(),
"Test": self.tree_node._children[0].get_name(),
"Test2": self.tree_node._children[1].get_name(),
"Test Folder2": self.tree_node._children[2].get_name(),
"Test3": self.tree_node._children[2]._children[0].get_name()
}
for expected, values in tests.items():
self.assertEqual(expected, values)
def test_get_updated_at(self) -> None:
self.assertEqual(1022, self.tree_node.get_updated_at())
self.assertEqual(1022, self.tree_node._children[0].get_updated_at())
self.assertEqual(1024, self.tree_node._children[1].get_updated_at())
self.assertEqual(1025, self.tree_node._children[2].get_updated_at())
self.assertEqual(
1026, self.tree_node._children[2]._children[0].get_updated_at())
def test_get_children(self) -> None:
self.assertEqual(self.folders[0], self.tree_node.get_payload())
self.assertEqual(self.files[0],
self.tree_node._children[0].get_payload())
self.assertEqual(self.files[1],
self.tree_node._children[1].get_payload())
self.assertEqual(self.folders[1],
self.tree_node._children[2].get_payload())
self.assertEqual(
self.files[2],
self.tree_node._children[2]._children[0].get_payload())
def test_get_payload(self) -> None:
self.assertEqual(3, len(self.tree_node.get_children()))
self.assertEqual(
self.files[2],
self.tree_node._children[2]._children[0].get_payload())
def test_parent(self) -> None:
self.assertEqual(self.tree_node, self.tree_node._children[0]._parent)
self.assertEqual(self.tree_node, self.tree_node._children[1]._parent)
self.assertEqual(self.tree_node, self.tree_node._children[2]._parent)
self.assertEqual(self.tree_node._children[2],
self.tree_node._children[2]._children[0]._parent)
def test_add_node_exception(self) -> None:
root = TreeNode(self.files[0])
with self.assertRaises(ValueError):
root.add_node(TreeNode(self.files[1]))
def test_str(self) -> None:
res = ("Test Folder - Folder (1022 -> 01/01/1970 00:17:02)\n"
" Test (1022 -> 01/01/1970 00:17:02)\n"
" Test2 (1024 -> 01/01/1970 00:17:04)\n"
" Test Folder2 - Folder (1025 -> 01/01/1970 00:17:05)\n"
" Test3 (1026 -> 01/01/1970 00:17:06)\n")
self.assertEqual(res, str(self.tree_node))
