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 RemoteFileViewTest(default_code.DefaultCode):
@patch(
'src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code.create_folder_with_files(
["default_test1", "default_test2", "default_test3"]))
def setUp(self, mock) -> None:
super().setUp()
self.main_model = MainModel()
self.main_model.remote_file_model
self.file_view_test = RemoteFileView(self.main_model)
def tearDown(self) -> None:
super().tearDown()
@patch(
'src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code.create_folder_with_files(
["test1", "test2", "test3"]))
def test_model_changed_files(self, mock):
self.file_view_test.Sl_model_changed()
test_list = self.file_view_test.fileLayout._item_list
self.assertEqual(test_list[0].wid.name == "test1", True)
self.assertEqual(test_list[1].wid.name == "test2", True)
self.assertEqual(test_list[2].wid.name == "test3", True)
@patch(
'src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code.create_folder_with_folders(
["test1", "test2", "test3"]))
def test_model_changed_dirs(self, mock):
self.file_view_test.Sl_model_changed()
test_list = self.file_view_test.fileLayout._item_list
self.assertEqual(test_list[0].wid.name == "test1", True)
self.assertEqual(test_list[1].wid.name == "test2", True)
self.assertEqual(test_list[2].wid.name == "test3", True)
@patch(
'src.algorithm.tree_builder.get_tree_from_node_id',
return_value=default_code.create_folder_with_files(
["test1", "test2", "test3"]))
def test_refresh_button(self, mock):
result = self.file_view_test._model.folder_queue = ["NOT_LOCAL_ROOT"]
self.file_view_test.Sl_refresh_button_clicked()
result = self.file_view_test._model.folder_queue == ["LOCAL_ROOT"]
self.assertEqual(result, True)
def test_add_sync_file_exists(self):
self.file_view_test.Sl_add_sync_file("test")
def test_remove_sync_file_exists(self):
self.file_view_test.Sl_remove_sync_file("test")
def test_file_status_changed_exists(self):
self.file_view_test.Sl_file_status_changed()
class RemoteFileModelTest(default_code.DefaultCode):
def setUp(self):
"""Metodo che viene chiamato prima di ogni metodo"""
super().setUp()
self.main_model = MainModel()
self.model_test = self.main_model.remote_file_model
def tearDown(self):
"""Metodo che viene chiamato dopo ogni metodo"""
super().tearDown()
self.model_test.folder_queue.clear()
self.model_test.folder_queue.append("LOCAL_ROOT")
def test_set_network_model(self):
network_model = self.main_model.network_model
self.model_test.set_network_model(network_model)
self.assertEqual(tree_builder.networkmodel, network_model)
@patch('src.algorithm.tree_builder.get_tree_from_node_id',
return_value=True)
def test_get_current_tree(self, mocked_get_tree_from_node):
result = self.model_test.get_current_tree()
mocked_get_tree_from_node.assert_called_once()
self.assertEqual(result, True)
@patch('src.model.remote_file_model.RemoteFileModel.get_current_tree',
return_value=default_code.create_folder_with_files(["TestFile"]))
def test_get_data_file(self, mocked_get_tree_from_node):
file_result, dir_result = self.model_test.get_data()
self.assertEqual(file_result[-1].get_name(), "TestFile")
@patch('src.model.remote_file_model.RemoteFileModel.get_current_tree',
return_value=default_code.create_folder_with_folders(["TestFolder"])
)
def test_get_data_folder(self, mocked_get_tree_from_node):
file_result, dir_result = self.model_test.get_data()
self.assertEqual(dir_result[-1].get_name(), "TestFolder")
@patch('src.model.remote_file_model.RemoteFileModel.get_current_tree',
return_value=default_code.create_folder_with_files(["TestFile"]))
def test_get_data_not_prev_dir(self, mocked_get_tree_from_node):
self.model_test.folder_queue.append("NonRoot")
file_result, dir_result = self.model_test.get_data()
self.assertEqual(dir_result[0].get_name(), "..")
@patch('src.model.remote_file_model.RemoteFileModel.get_current_tree',
return_value=default_code.create_folder_with_files(["TestFile"]))
def test_get_data_exception(self, mocked_get_tree_from_node):
mocked_get_tree_from_node.side_effect = APIException
test_result = self.model_test.get_data()
self.assertEqual(test_result, None)
def test_set_current_node_descend(self):
self.model_test.set_current_node("TestNode")
self.assertEqual(self.model_test.folder_queue[-1], "TestNode")
def test_set_current_node_ascend(self):
self.model_test.folder_queue.append("TestNode")
self.model_test.folder_queue.append("SecondNode")
self.model_test.set_current_node("SecondNode")
self.assertEqual(self.model_test.folder_queue[-1], "TestNode")
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_compare_folders_equals(self):
node = default_code.create_folder_with_folders(self.FILE_NAME)
result = tree_comparator.compareFolders(node, node)
# Empty list, nothing to do
self.assertEqual(result, [])