def test_download_fail_for_quota(self, download_mock, get_content_mock):
expected_result = {
"node_name": default_code._get_test_node().get_name(),
"result": False,
"type": "space_error"
}
result = self.model_test.download_node(default_code._get_test_node(),
"test", 0)
get_content_mock.assert_called_once()
self.assertEqual(download_mock.call_count, 0)
self.assertEqual(result, expected_result)
def test_download_success(self, download_mock, get_content_mock):
expected_result = {
"node_name": default_code._get_test_node().get_name(),
"result": True,
"type": ""
}
result = self.model_test.download_node(default_code._get_test_node(),
"test", 100)
download_mock.assert_called_once()
get_content_mock.assert_called_once()
self.assertEqual(result, expected_result)
def test_download_fail_for_network_error(self, download_mock,
get_content_mock):
expected_result = {
"node_name": default_code._get_test_node().get_name(),
"result": False,
"type": "network_error"
}
result = self.model_test.download_node(default_code._get_test_node(),
"test", 100)
download_mock.assert_called_once()
get_content_mock.assert_called_once()
self.assertEqual(result, expected_result)
def test_get_only_folders(self):
file_name = ["ciao", "mamma"]
first_folder_node = default_code._get_test_node()
second_file_node = default_code._get_file_test_node(file_name[0])
file_node = default_code._get_file_test_node(file_name[1])
result = tree_comparator._get_only_folders([first_folder_node,
second_file_node,
file_node])
self.assertEqual([first_folder_node], result)
class RemoteFileWidgetTest(default_code.DefaultCode):
@patch('src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code._get_test_node())
def setUp(self, mocked) -> None:
"""Metodo che viene chiamato prima di ogni metodo"""
super().setUp()
self.test_model = MainModel()
self.test_file_view = RemoteFileView(self.test_model)
self.test_file = RemoteFile(default_code._get_file_test_node("test"))
self.test_file_widget = RemoteFileWidget(
self.test_file, self.test_model.settings_model)
def tearDown(self):
"""Metodo che viene chiamato dopo ogni metodo"""
def test_double_click_present(self):
self.test_model.settings_model.add_id_to_sync_list("CLIENT_NODE")
self.test_file_widget.Sl_on_double_click()
result = self.test_model.settings_model.is_id_in_sync_list(
self.test_file.id)
self.assertEqual(result, True)
self.test_model.settings_model.remove_id_from_sync_list("CLIENT_NODE")
def test_double_click_absent(self):
self.test_model.settings_model.add_id_to_sync_list("NOT_CLIENT_NODE")
self.test_file_widget.Sl_on_double_click()
result = self.test_model.settings_model.is_id_in_sync_list(
self.test_file.id)
self.assertEqual(result, False)
self.test_model.settings_model.remove_id_from_sync_list(
"NOT_CLIENT_NODE")
@patch('PySide6.QtGui.QPainter.drawPixmap')
def test_show_synced(self, mocked):
self.test_file_widget.show_synced()
mocked.assert_called()
@patch('PySide6.QtGui.QPainter.drawPixmap')
def test_files_status_changed_synced(self, mocked):
self.test_model.settings_model.add_id_to_sync_list("CLIENT_NODE")
self.test_file_widget.Sl_on_file_status_changed()
mocked.assert_called()
self.test_model.settings_model.remove_id_from_sync_list("CLIENT_NODE")
@patch('PySide6.QtGui.QPainter.drawPixmap')
def test_files_status_changed_not_synced(self, mocked):
self.test_file_widget.Sl_on_file_status_changed()
mocked.assert_not_called()
def test_compare_folders_server_new_folder(self):
# Imposto cartella server
server_node = default_code.create_folder_with_folders(self.FILE_NAME)
# imposto cartella client
client_node = default_code.create_folder_with_folders(self.FILE_NAME)
# Imposto file mancante
missing_file = default_code._get_test_node()
# Aggiungo file mancante
server_node.add_node(missing_file)
result = tree_comparator.compareFolders(client_node, server_node)
# expected result
exp_result = [{
'node': missing_file,
'path': missing_file.get_payload().path,
'action': Actions.SERVER_NEW_FOLDER}]
self.assertEqual(result, exp_result)
class RemoteDirectoryWidgetTest(default_code.DefaultCode):
@patch(
'src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code._get_test_node())
def setUp(self, mocked) -> None:
super().setUp()
node = default_code.create_folder_with_files(["testFile"])
base_dir = RemoteDirectory(node)
self.test_model = MainModel()
self.test_view = RemoteFileView(self.test_model)
self.test_dir = RemoteDirectoryWidget(base_dir, self.test_view)
def tearDown(self) -> None:
super().tearDown()
def test_double_clicked_action(self):
self.test_dir.double_clicked_action()
class CompareClientSnapshotTest(default_code.DefaultCode):
def setUp(self) -> None:
super().setUp()
self.env_settings = super().get_env_settings()
self.context = CompareSnapClient()
def tearDown(self) -> None:
super().tearDown()
@patch('src.algorithm.tree_comparator.compareFolders', return_value="")
def test_compare_snap_client_equal_client_strategy(self, mocked_fun):
test_node = _get_test_node()
self.context.check(test_node, test_node, ClientStrategy())
mocked_fun.assert_called_once()
@patch('src.algorithm.tree_comparator.compareFolders', return_value="")
def test_compare_snap_client_equal_manual_strategy(self, mocked_fun):
test_node = _get_test_node()
self.context.check(test_node, test_node, ManualStrategy())
mocked_fun.assert_called_once()
@patch('src.algorithm.tree_comparator.compareFolders',
return_value=ResultObj(Actions.SERVER_NEW_FOLDER, 1))
@patch('src.algorithm.os_handler.create_folder')
@patch('src.algorithm.tree_builder.get_tree_from_node_id', return_value=_get_test_node())
def test_compare_snap_client_server_new_folder(self, mock_get_tree, mock_create_folder, mock_3):
test_node = _get_test_node()
self.context.check(test_node, test_node, ClientStrategy())
self.assertEqual(mock_get_tree.call_count, 3)
self.assertEqual(mock_create_folder.call_count, 3)
mock_3.assert_called_once()
@patch('src.algorithm.tree_comparator.compareFolders',
return_value=ResultObj(Actions.SERVER_NEW_FILE, 1))
@patch('src.algorithm.os_handler.upload_file')
@patch('src.algorithm.strategy.strategy.get_or_create_folder_id')
def test_compare_snap_client_server_new_file(self, mock_1, mock_2, mock_3):
test_node = _get_test_node()
self.context.check(test_node, test_node, ClientStrategy())
mock_1.assert_called_once()
mock_2.assert_called_once()
mock_3.assert_called_once()
def test_double_clicked_action_exists_local(self):
test_dir = LocalDirectory(default_code._get_test_node())
test_dir_widget = LocalDirectoryWidget(test_dir)
test_dir_widget.double_clicked_action()
def test_compute_decision_new_server_folder(self, mock_1, mock_2, mock_3):
test_node = _get_test_node()
self.decision_engine.compute_decision(test_node, test_node, True)
mock_1.assert_called_once()
mock_2.assert_called_once()
mock_3.assert_called_once()
def test_compute_decision_new_server_update_file(self, mock_1, mock_2):
test_node = _get_test_node()
self.decision_engine.compute_decision(test_node, test_node, True)
mock_1.assert_called_once()
mock_2.assert_called_once()
def test_compute_decision_new_client_folder_snap_false(
self, mock_1, mock_2):
test_node = _get_test_node()
self.decision_engine.compute_decision(test_node, test_node, False)
mock_1.assert_called_once()
mock_2.assert_called_once()
def test_compute_decision_new_client_file_snap_True(self, mock_1, mock_2):
test_node = _get_test_node()
self.decision_engine.compute_decision(test_node, test_node, True)
mock_1.assert_called_once()
mock_2.assert_called_once()
def test_compare_snap_client_server_new_folder(self, mock_get_tree, mock_create_folder, mock_3):
test_node = _get_test_node()
self.context.check(test_node, test_node, ClientStrategy())
self.assertEqual(mock_get_tree.call_count, 3)
self.assertEqual(mock_create_folder.call_count, 3)
mock_3.assert_called_once()
class StrategyTest(default_code.DefaultCode):
def setUp(self) -> None:
super(StrategyTest, self).setUp()
self.client_strategy = ClientStrategy()
self.manual_strategy = ManualStrategy()
# setup per manual strategy
os_handler.set_network_model(MainModel().network_model)
self.env_set = super().get_env_settings()
# create files
self.original_path = self.env_settings.value(super().SYNC_ENV_VARIABLE)
self.folder_name = "test"
self.file_name = "test.txt"
self.path = os.path.join(self.original_path, "tree")
self.path = r'%s' % self.path
pathlib.Path(self.path).mkdir(parents=True, exist_ok=True)
self.first_folder = os.path.join(self.path, self.folder_name)
pathlib.Path(self.first_folder).mkdir(parents=True, exist_ok=True)
with open(os.path.join(self.first_folder, self.file_name), "w"):
pass
def delete_files(self):
file_to_remove = os.path.join(self.first_folder, self.file_name)
try:
if os.path.exists(file_to_remove):
os.remove(file_to_remove)
except Exception as e:
print(e)
try:
if os.path.exists(self.first_folder):
os.rmdir(self.first_folder)
except Exception as e:
print(e)
try:
if os.path.exists(self.path):
os.rmdir(self.path)
except Exception as e:
print(e)
def tearDown(self) -> None:
self.delete_files()
super(StrategyTest, self).tearDown()
@patch('src.algorithm.strategy.client_strategy.get_or_create_folder_id',
return_value=None)
@patch('src.algorithm.os_handler.upload_file')
def test_execute_client_strategy_server_update_file(self, mock_1, mock_2):
obj_to_iterate: list = [
default_code.ResultObj(Actions.SERVER_UPDATE_FILE).result
]
logger = default_code.FakeLogger()
self.client_strategy.execute(obj_to_iterate, logger)
mock_1.assert_called_once()
mock_2.assert_called_once()
@patch('src.algorithm.strategy.client_strategy.common_strategy')
def test_execute_client_strategy_common(self, mock_1):
obj_to_iterate: list = [
default_code.ResultObj(Actions.CLIENT_UPDATE_FILE).result,
default_code.ResultObj(Actions.CLIENT_NEW_FOLDER).result,
default_code.ResultObj(Actions.CLIENT_NEW_FILE).result,
default_code.ResultObj(Actions.SERVER_NEW_FOLDER).result,
default_code.ResultObj(Actions.SERVER_NEW_FILE).result
]
logger = default_code.FakeLogger()
self.client_strategy.execute(obj_to_iterate, logger)
self.assertEqual(mock_1.call_count, 5)
@patch('src.model.network_model.NetworkModel.get_content_from_node',
return_value=default_code._get_special_tree_dict())
@patch('src.algorithm.strategy.manual_strategy.get_or_create_folder_id',
return_value=None)
@patch('src.algorithm.os_handler.upload_file')
@patch('os.rename')
@patch('src.algorithm.tree_builder._build_tree_node',
return_value=default_code._get_test_node())
@patch('src.algorithm.strategy.manual_strategy.check_node_still_exists',
return_value=True)
def test_execute_manual_strategy_server_update_file_diff_snap(
self, mock_1, mock_2, mock_3, mock_4, mock_5, mock_6):
obj_to_iterate: list = [
default_code.ResultObj(Actions.SERVER_UPDATE_FILE, 0,
"name.ciao.we").result
]
logger = default_code.FakeLogger()
self.manual_strategy.execute(obj_to_iterate, logger)
mock_1.assert_called_once()
mock_2.assert_called_once()
mock_3.assert_called_once()
mock_4.assert_called_once()
mock_5.assert_called_once()
mock_6.assert_called_once()
@patch('src.algorithm.strategy.manual_strategy.get_or_create_folder_id',
return_value=None)
@patch('src.algorithm.os_handler.upload_file')
@patch('src.algorithm.strategy.manual_strategy.check_node_still_exists',
return_value=None)
def test_execute_manual_strategy_server_update_file_none(
self, mock_1, mock_2, mock_3):
obj_to_iterate: list = [
default_code.ResultObj(Actions.SERVER_UPDATE_FILE, 0,
"name.ciao.we").result
]
logger = default_code.FakeLogger()
self.manual_strategy.execute(obj_to_iterate, logger)
mock_1.assert_called_once()
mock_2.assert_called_once()
mock_3.assert_called_once()
@patch('src.model.network_model.NetworkModel.get_content_from_node',
return_value=default_code._get_special_tree_dict())
@patch('src.algorithm.strategy.manual_strategy.get_or_create_folder_id',
return_value=None)
@patch('src.algorithm.os_handler.upload_file')
@patch('src.algorithm.tree_builder._create_node_from_dict',
return_value=default_code._get_test_node())
@patch('src.algorithm.strategy.manual_strategy.check_node_still_exists',
return_value=True)
def test_execute_manual_strategy_server_update_file_equal_snap(
self, mock_1, mock_2, mock_3, mock_4, mock_5):
obj_to_iterate: list = [
default_code.ResultObj(Actions.SERVER_UPDATE_FILE, 0,
"name.ciao.we", 200).result
]
logger = default_code.FakeLogger()
self.manual_strategy.execute(obj_to_iterate, logger)
mock_1.assert_called_once()
mock_2.assert_called_once()
mock_3.assert_called_once()
mock_4.assert_called_once()
mock_5.assert_called_once()
@patch('src.algorithm.strategy.manual_strategy.common_strategy')
def test_execute_manual_strategy_common(self, mock_1):
logger = default_code.FakeLogger()
obj_to_iterate: list = [
default_code.ResultObj(Actions.CLIENT_UPDATE_FILE).result,
default_code.ResultObj(Actions.CLIENT_NEW_FOLDER).result,
default_code.ResultObj(Actions.CLIENT_NEW_FILE).result,
default_code.ResultObj(Actions.SERVER_NEW_FOLDER).result,
default_code.ResultObj(Actions.SERVER_NEW_FILE).result
]
self.manual_strategy.execute(obj_to_iterate, logger)
self.assertEqual(mock_1.call_count, 5)
@patch('src.algorithm.os_handler.create_folder')
@patch('src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code.create_folder_with_folders(
["tree", "tree"]))
def test_get_or_create_id_found(self, get_tree_mock, create_folder_mock):
client_result = strategy.get_or_create_folder_id(self.first_folder)
self.assertEqual(get_tree_mock.call_count, 2)
manual_result = strategy.get_or_create_folder_id(self.first_folder)
self.assertEqual(get_tree_mock.call_count, 4)
self.assertEqual(client_result, manual_result)
@patch('src.algorithm.os_handler.create_folder')
@patch('src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code.create_folder_with_folders(["x", "x"]))
def test_get_or_create_id_not_found(self, get_tree_mock,
create_folder_mock):
client_result = strategy.get_or_create_folder_id(self.first_folder)
self.assertEqual(create_folder_mock.call_count, 2)
self.assertEqual(get_tree_mock.call_count, 3)
manual_result = strategy.get_or_create_folder_id(self.first_folder)
self.assertEqual(create_folder_mock.call_count, 4)
self.assertEqual(get_tree_mock.call_count, 6)
self.assertEqual(client_result, manual_result)
@patch('src.algorithm.strategy.strategy.check_node_still_exists',
return_value="a")
@patch('src.algorithm.os_handler.delete_node', return_value=True)
def test_common_strategy_client_new_folder(self, m1, m2):
node_raw = {
"action":
Actions.CLIENT_NEW_FOLDER,
"node":
TreeNode(Node("a", "ciao.txt", Type.File, 100, 200, "a/ciao.txt"))
}
logger = default_code.FakeLogger()
strategy.common_strategy(node_raw, logger)
m1.assert_called_once()
m2.assert_called_once()
@patch('src.algorithm.strategy.strategy.check_node_still_exists',
return_value="a")
@patch('src.algorithm.os_handler.delete_node', return_value=True)
def test_common_strategy_client_new_file(self, m1, m2):
node_raw = {
"action":
Actions.CLIENT_NEW_FILE,
"node":
TreeNode(Node("a", "ciao.txt", Type.File, 100, 200, "a/ciao.txt"))
}
logger = default_code.FakeLogger()
strategy.common_strategy(node_raw, logger)
m1.assert_called_once()
m2.assert_called_once()
@patch('src.algorithm.strategy.strategy.check_node_still_exists',
return_value=None)
@patch('src.algorithm.os_handler.delete_node', return_value=True)
def test_common_strategy_client_new_folder_id_not_exists(self, m1, m2):
node_raw = {
"action":
Actions.CLIENT_NEW_FOLDER,
"node":
TreeNode(Node("a", "ciao.txt", Type.File, 100, 200, "a/ciao.txt"))
}
logger = default_code.FakeLogger()
strategy.common_strategy(node_raw, logger)
m1.assert_not_called()
m2.assert_called_once()
@patch('src.algorithm.strategy.strategy.check_node_still_exists',
return_value=None)
@patch('src.algorithm.os_handler.delete_node', return_value=True)
def test_common_strategy_client_new_file_id_not_exists(self, m1, m2):
node_raw = {
"action":
Actions.CLIENT_NEW_FILE,
"node":
TreeNode(Node("a", "ciao.txt", Type.File, 100, 200, "a/ciao.txt"))
}
logger = default_code.FakeLogger()
strategy.common_strategy(node_raw, logger)
m1.assert_not_called()
m2.assert_called_once()
@patch('src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code.create_folder_with_folders(
["tree", "tree"]))
def test_check_node_still_exists(self, m1):
result = strategy.check_node_still_exists(os.path.join("test", "tree"))
m1.assert_called_once()
self.assertEqual(result, "CLIENT_NODE")
@patch('src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code.create_folder_with_folders(
["tree", "tree"]))
def test_check_node_still_exists_not_found(self, m1):
result = strategy.check_node_still_exists(os.path.join(
"test", "tree2"))
m1.assert_called_once()
self.assertIsNone(result)
def test_on_double_click_exists(self):
test_file = File(default_code._get_test_node())
test_widget = FileWidget(test_file)
test_widget.Sl_on_double_click()
def test_upload_node(self, mock_upload):
self.model_test.upload_node(default_code._get_test_node(), "test")
mock_upload.assert_called_once()
def test_compare_snap_client_equal_manual_strategy(self, mocked_fun):
test_node = _get_test_node()
self.context.check(test_node, test_node, ManualStrategy())
mocked_fun.assert_called_once()
def test_compare_snap_client_server_new_file(self, mock_1, mock_2, mock_3):
test_node = _get_test_node()
self.context.check(test_node, test_node, ClientStrategy())
mock_1.assert_called_once()
mock_2.assert_called_once()
mock_3.assert_called_once()
class OsHandlerTest(default_code.DefaultCode):
def setUp(self) -> None:
super().setUp()
self.env_settings = super().get_env_settings()
self.main_model = MainModel()
os_handler.set_network_model(self.main_model.network_model)
os_handler.set_settings_model(self.main_model.settings_model)
self.original_path = self.env_settings.value(super().SYNC_ENV_VARIABLE)
self.folder_name = "test"
self.file_name = "test.txt"
self.path = os.path.join(self.original_path, "tree")
self.path = r'%s' % self.path
pathlib.Path(self.path).mkdir(parents=True, exist_ok=True)
def delete_files(self):
folder_to_remove = os.path.join(self.path, self.folder_name)
file_to_remove = os.path.join(folder_to_remove, self.file_name)
optional_folder = os.path.join(folder_to_remove, self.folder_name)
try:
if os.path.exists(file_to_remove):
os.remove(file_to_remove)
except Exception as e:
print(e)
try:
if os.path.exists(optional_folder):
os.rmdir(optional_folder)
except Exception as e:
print(e)
try:
if os.path.exists(folder_to_remove):
os.rmdir(folder_to_remove)
except Exception as e:
print(e)
try:
if os.path.exists(self.path):
os.rmdir(self.path)
except Exception as e:
print(e)
def tearDown(self) -> None:
self.delete_files()
super().tearDown()
def test_set_model(self):
os_handler.set_network_model(None)
self.assertIsNone(os_handler.network_model)
os_handler.set_network_model(self.main_model.network_model)
self.assertEqual(os_handler.network_model, self.main_model.network_model)
@patch('src.model.network_model.NetworkModel.download_node', return_value=True)
@patch('src.model.settings_model.SettingsModel.is_id_in_sync_list', return_value=True)
@patch('src.algorithm.os_handler.check_node_in_nodelist', return_value=True)
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)
@patch('src.model.network_model.NetworkModel.upload_node', return_value=None)
@patch('src.model.network_model.NetworkModel.create_folder', return_value=None)
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()
@patch('src.model.network_model.NetworkModel.create_folder', return_value=None)
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)
@patch('src.model.settings_model.SettingsModel.is_id_in_sync_list', return_value=False)
def test_download_file_not_in_list(self, mocked_fun):
test_node = TreeNode(Node("CLIENT_NODE", self.folder_name,
Type.File, 100, 200, "ciao.txt"))
res = os_handler.download_file(test_node, self.path)
mocked_fun.assert_called_once()
self.assertIsNone(res)
@patch('src.model.settings_model.SettingsModel.get_sync_list', return_value=["a", "b"])
@patch('src.model.network_model.NetworkModel.delete_node')
def test_delete_node_file_present(self, m1, m2):
res = os_handler.delete_node("a", True)
m1.assert_called_once()
m2.assert_called_once()
self.assertTrue(res)
@patch('src.model.settings_model.SettingsModel.get_sync_list', return_value=["a", "b"])
def test_delete_node_file_not_present(self, m1):
res = os_handler.delete_node("c", True)
m1.assert_called_once()
self.assertFalse(res)
@patch('src.model.settings_model.SettingsModel.get_sync_list', return_value=["a", "b"])
@patch('src.algorithm.tree_builder.get_tree_from_node_id', return_value=_get_test_node())
@patch('src.algorithm.os_handler.check_node_in_nodelist', return_value=True)
@patch('src.model.network_model.NetworkModel.delete_node')
def test_delete_node_folder_present(self, m1, m2, m3, m4):
res = os_handler.delete_node("a", False)
m1.assert_called_once()
m2.assert_called_once()
m3.assert_called_once()
m4.assert_called_once()
self.assertTrue(res)
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)
