Add the tests for the application class

Add the tests for the update on photo service

tests/service/test_photo_service.py

@@ -1,5 +1,7 @@
 import pytest
 from pathlib import Path
+
+from pilgrim import TravelDiary
 from pilgrim.service.photo_service import PhotoService
 import hashlib
 from unittest.mock import patch
@@ -109,6 +111,114 @@ def test_check_photo_by_hash_returns_none_when_not_found(session_with_photos):
     result2 = service.check_photo_by_hash(existing_hash, invalid_diary_id)
     assert result2 is None
 
+def test_update_photo_metadata_successfully(session_with_photos):
+    session, photos = session_with_photos
+    service = PhotoService(session)
+    photo_to_update = photos[0]
+    photo_with_new_data = Photo(
+        filepath=photo_to_update.filepath,
+        name="Novo Nome da Foto",
+        caption="Nova legenda para a foto.",
+        photo_hash=photo_to_update.photo_hash,  # O hash não muda
+        addition_date=photo_to_update.addition_date,
+        fk_travel_diary_id=photo_to_update.fk_travel_diary_id
+    )
+    updated_photo = service.update(photo_to_update, photo_with_new_data)
+    assert updated_photo is not None
+    assert updated_photo.name == "Novo Nome da Foto"
+    assert updated_photo.caption == "Nova legenda para a foto."
+    assert updated_photo.photo_hash == photo_to_update.photo_hash
+    photo_in_db = session.query(Photo).get(photo_to_update.id)
+    assert photo_in_db.name == "Novo Nome da Foto"
+
+
+@patch.object(PhotoService, 'hash_file')
+@patch('pathlib.Path.unlink')
+@patch('pathlib.Path.exists')
+@patch.object(PhotoService, '_copy_photo_to_diary')
+@patch.object(DirectoryManager, 'get_diaries_root', return_value="/fake/diaries_root")
+def test_update_photo_with_new_file_successfully(
+    mock_get_root, mock_copy, mock_exists, mock_unlink, mock_hash, session_with_photos
+):
+    session, photos = session_with_photos
+    service = PhotoService(session)
+    photo_to_update = photos[0]
+    new_source_path = Path("/path/para/nova_imagem.jpg")
+    new_copied_path = Path(f"/fake/diaries_root/{photo_to_update.travel_diary.directory_name}/images/nova_imagem.jpg")
+
+    mock_copy.return_value = new_copied_path
+    mock_exists.return_value = True
+    mock_hash.return_value = "novo_hash_calculado"
+    photo_with_new_file = Photo(
+        filepath=new_source_path,
+        name=photo_to_update.name,
+        photo_hash="hash_antigo",
+        fk_travel_diary_id=photo_to_update.fk_travel_diary_id
+    )
+    updated_photo = service.update(photo_to_update, photo_with_new_file)
+    mock_copy.assert_called_once_with(new_source_path, photo_to_update.travel_diary)
+    mock_unlink.assert_called_once()
+    mock_hash.assert_called_once_with(new_copied_path)
+    assert updated_photo.filepath == str(new_copied_path)
+    assert updated_photo.photo_hash == "novo_hash_calculado"
+
+def test_update_photo_returns_none_if_photo_does_not_exist(db_session):
+    service = PhotoService(db_session)
+    non_existent_photo_src = Photo(
+        filepath="/fake/path.jpg", name="dummy",
+        photo_hash="dummy", fk_travel_diary_id=1
+    )
+    non_existent_photo_src.id = 999
+    photo_with_new_data = Photo(
+        filepath="/fake/new.jpg", name="new dummy",
+        photo_hash="new_dummy", fk_travel_diary_id=1
+    )
+    result = service.update(non_existent_photo_src, photo_with_new_data)
+    assert result is None
+
+
+@patch.object(PhotoService, 'hash_file')
+@patch('pathlib.Path.unlink')
+@patch('pathlib.Path.exists')
+@patch.object(PhotoService, '_copy_photo_to_diary')
+@patch.object(DirectoryManager, 'get_diaries_root', return_value="/fake/diaries_root")
+def test_update_photo_with_new_file_successfully(
+    mock_get_root, mock_copy, mock_exists, mock_unlink, mock_hash, session_with_photos
+):
+    session, photos = session_with_photos
+    service = PhotoService(session)
+    photo_to_update = photos[0]
+    new_source_path = Path("/path/para/nova_imagem.jpg")
+    new_copied_path = Path(f"/fake/diaries_root/{photo_to_update.travel_diary.directory_name}/images/nova_imagem.jpg")
+    mock_copy.return_value = new_copied_path
+    mock_exists.return_value = True
+    mock_hash.return_value = "novo_hash_calculado"
+    photo_with_new_file = Photo(
+        filepath=new_source_path, name=photo_to_update.name,
+        photo_hash="hash_antigo", fk_travel_diary_id=photo_to_update.fk_travel_diary_id
+    )
+    updated_photo = service.update(photo_to_update, photo_with_new_file)
+    mock_copy.assert_called_once_with(new_source_path, photo_to_update.travel_diary)
+    mock_unlink.assert_called_once()
+    mock_hash.assert_called_once_with(new_copied_path)
+
+    assert updated_photo.filepath == str(new_copied_path)
+    assert updated_photo.photo_hash == "novo_hash_calculado"
+
+@patch.object(DirectoryManager, 'get_diary_images_directory')
+def test_copy_photo_to_diary_handles_name_collision_with_patch(mock_get_images_dir, db_session, tmp_path: Path):
+    images_dir = tmp_path / "images"
+    images_dir.mkdir()
+    mock_get_images_dir.return_value = images_dir
+    source_file = tmp_path / "foto.jpg"
+    source_file.touch()
+    (images_dir / "foto.jpg").touch()
+    service = PhotoService(db_session)
+    fake_diary = TravelDiary(name="test",directory_name="fake_diary")
+    copied_path = service._copy_photo_to_diary(source_file, fake_diary)
+    assert copied_path.name == "foto_1.jpg"
+    assert copied_path.exists()
+
 @patch('pathlib.Path.unlink')
 @patch('pathlib.Path.exists')
 @patch.object(DirectoryManager, 'get_diaries_root', return_value="/fake/diaries_root")

tests/service/test_service_manager.py

@@ -0,0 +1,33 @@
+from pilgrim.service.servicemanager import ServiceManager
+from unittest.mock import patch, MagicMock
+
+def test_initial_state_is_none():
+    manager = ServiceManager()
+    assert manager.get_session() is None
+    assert manager.get_entry_service() is None
+    assert manager.get_photo_service() is None
+    assert manager.get_travel_diary_service() is None
+
+@patch('pilgrim.service.servicemanager.TravelDiaryService')
+@patch('pilgrim.service.servicemanager.PhotoService')
+@patch('pilgrim.service.servicemanager.EntryService')
+def test_get_services_instantiates_with_correct_session(
+    mock_entry_service, mock_photo_service, mock_travel_diary_service
+):
+    manager = ServiceManager()
+    mock_session = MagicMock()
+    manager.set_session(mock_session)
+
+    entry_service_instance = manager.get_entry_service()
+    photo_service_instance = manager.get_photo_service()
+    travel_diary_service_instance = manager.get_travel_diary_service()
+
+    mock_entry_service.assert_called_once()
+    mock_photo_service.assert_called_once()
+    mock_travel_diary_service.assert_called_once()
+    mock_entry_service.assert_called_once_with(mock_session)
+    mock_photo_service.assert_called_once_with(mock_session)
+    mock_travel_diary_service.assert_called_once_with(mock_session)
+    assert entry_service_instance == mock_entry_service.return_value
+    assert photo_service_instance == mock_photo_service.return_value
+    assert travel_diary_service_instance == mock_travel_diary_service.return_value

tests/test_application.py

@@ -0,0 +1,56 @@
+from unittest.mock import patch, MagicMock
+from pilgrim.application import Application
+
+@patch('pilgrim.application.UIApp')
+@patch('pilgrim.application.ServiceManager')
+@patch('pilgrim.application.Database')
+@patch('pilgrim.application.ConfigManager')
+def test_application_initialization_wires_dependencies(
+    MockConfigManager, MockDatabase, MockServiceManager, MockUIApp
+):
+    mock_config_instance = MockConfigManager.return_value
+    mock_db_instance = MockDatabase.return_value
+    mock_session_instance = mock_db_instance.session.return_value
+    mock_service_manager_instance = MockServiceManager.return_value
+    app = Application()
+    MockConfigManager.assert_called_once()
+    MockDatabase.assert_called_once_with(mock_config_instance)
+    MockServiceManager.assert_called_once()
+    MockUIApp.assert_called_once_with(mock_service_manager_instance, mock_config_instance)
+    mock_config_instance.read_config.assert_called_once()
+    mock_db_instance.session.assert_called_once()
+    mock_service_manager_instance.set_session.assert_called_once_with(mock_session_instance)
+
+@patch('pilgrim.application.UIApp')
+@patch('pilgrim.application.ServiceManager')
+@patch('pilgrim.application.Database')
+@patch('pilgrim.application.ConfigManager')
+def test_application_run_calls_methods(
+    MockConfigManager, MockDatabase, MockServiceManager, MockUIApp
+):
+    app = Application()
+    mock_db_instance = app.database
+    mock_ui_instance = app.ui
+    app.run()
+    mock_db_instance.create.assert_called_once()
+    mock_ui_instance.run.assert_called_once()
+
+@patch('pilgrim.application.UIApp')
+@patch('pilgrim.application.ServiceManager')
+@patch('pilgrim.application.Database')
+@patch('pilgrim.application.ConfigManager')
+def test_get_service_manager_creates_and_configures_new_instance(
+    MockConfigManager, MockDatabase, MockServiceManager, MockUIApp
+):
+    app = Application()
+    mock_db_instance = app.database
+    fake_session = MagicMock()
+    mock_db_instance.session.return_value = fake_session
+    mock_db_instance.reset_mock()
+    MockServiceManager.reset_mock()
+    returned_manager = app.get_service_manager()
+    mock_db_instance.session.assert_called_once()
+    MockServiceManager.assert_called_once()
+    returned_manager.set_session.assert_called_once_with(fake_session)
+
+    assert returned_manager is MockServiceManager.return_value

tests/utils/test_config_manager.py

@@ -0,0 +1,67 @@
+import pytest
+import tomli
+from pathlib import Path
+from unittest.mock import patch
+
+from pilgrim.utils.config_manager import ConfigManager, SingletonMeta
+from pilgrim.utils.directory_manager import DirectoryManager
+
+@pytest.fixture
+def clean_singleton():
+    SingletonMeta._instances = {}
+
+@patch('pilgrim.utils.config_manager.DirectoryManager.get_config_directory')
+def test_create_default_config_if_not_exists_with_decorator(mock_get_config_dir, tmp_path: Path, clean_singleton):
+    mock_get_config_dir.return_value = str(tmp_path)
+    manager = ConfigManager()
+    config_file = tmp_path / "config.toml"
+    assert not config_file.exists()
+    manager.read_config()
+    assert config_file.exists()
+    assert manager.database_type == "sqlite"
+
+@patch('pilgrim.utils.config_manager.DirectoryManager.get_config_directory')
+def test_read_existing_config_with_decorator(mock_get_config_dir, tmp_path: Path, clean_singleton):
+    mock_get_config_dir.return_value = str(tmp_path)
+    custom_config_content = """
+    [database]
+    url = "/custom/path/to/db.sqlite"
+    type = "custom_sqlite"
+    [settings.diary]
+    auto_open_diary_on_startup = "MyCustomDiary"
+    auto_open_on_creation = true
+    """
+    config_file = tmp_path / "config.toml"
+    config_file.write_text(custom_config_content)
+
+    manager = ConfigManager()
+    manager.read_config()
+    assert manager.database_url == "/custom/path/to/db.sqlite"
+    assert manager.database_type == "custom_sqlite"
+
+@patch('pilgrim.utils.config_manager.DirectoryManager.get_config_directory')
+def test_save_config_writes_changes_to_file_with_decorator(mock_get_config_dir, tmp_path: Path, clean_singleton):
+    mock_get_config_dir.return_value = str(tmp_path)
+    manager = ConfigManager()
+    manager.read_config()
+    manager.set_database_url("/novo/caminho.db")
+    manager.set_auto_open_new_diary(True)
+    manager.save_config()
+    config_file = tmp_path / "config.toml"
+    with open(config_file, "rb") as f:
+        data = tomli.load(f)
+        assert data["database"]["url"] == "/novo/caminho.db"
+        assert data["settings"]["diary"]["auto_open_on_creation"] is True
+
+@patch('pilgrim.utils.config_manager.DirectoryManager.get_config_directory')
+def test_read_config_raises_error_on_malformed_toml(mock_get_config_dir, tmp_path: Path, clean_singleton):
+    mock_get_config_dir.return_value = str(tmp_path)
+    invalid_toml_content = """
+       [database]
+       url = /caminho/sem/aspas
+       """
+    config_file = tmp_path / "config.toml"
+    config_file.write_text(invalid_toml_content)
+    manager = ConfigManager()
+    with pytest.raises(ValueError, match="Invalid TOML configuration"):
+        manager.read_config()

tests/utils/test_directory_manager.py

@@ -0,0 +1,71 @@
+import shutil
+from pathlib import Path
+from unittest.mock import patch
+import pytest
+
+from pilgrim.utils.directory_manager import DirectoryManager
+
+@patch('os.chmod')
+@patch('pathlib.Path.home')
+def test_get_config_directory_creates_dir_in_fake_home(mock_home, mock_chmod, tmp_path: Path):
+    mock_home.return_value = tmp_path
+
+    expected_config_dir = tmp_path / ".pilgrim"
+    assert not expected_config_dir.exists()
+    result_path = DirectoryManager.get_config_directory()
+    assert result_path == expected_config_dir
+    assert expected_config_dir.exists()
+    mock_chmod.assert_called_once_with(expected_config_dir, 0o700)
+
+@patch('shutil.copy2')
+@patch('pathlib.Path.home')
+def test_get_database_path_no_migration(mock_home, mock_copy, tmp_path: Path):
+    mock_home.return_value = tmp_path
+    expected_db_path = tmp_path / ".pilgrim" / "database.db"
+    result_path = DirectoryManager.get_database_path()
+    assert result_path == expected_db_path
+    mock_copy.assert_not_called()
+
+@patch('shutil.copy2')
+@patch('pathlib.Path.home')
+def test_get_database_path_with_migration(mock_home, mock_copy, tmp_path: Path, monkeypatch):
+    fake_home_dir = tmp_path / "home"
+    fake_project_dir = tmp_path / "project"
+    fake_home_dir.mkdir()
+    fake_project_dir.mkdir()
+
+    (fake_project_dir / "database.db").touch()
+    mock_home.return_value = fake_home_dir
+    monkeypatch.chdir(fake_project_dir)
+    result_path = DirectoryManager.get_database_path()
+    expected_db_path = fake_home_dir / ".pilgrim" / "database.db"
+    assert result_path == expected_db_path
+
+    mock_copy.assert_called_once_with(
+        Path("database.db"),
+        expected_db_path
+    )
+
+@patch('os.chmod')
+@patch('pathlib.Path.home')
+def test_diary_path_methods_construct_correctly(mock_home, mock_chmod, tmp_path: Path):
+    mock_home.return_value = tmp_path
+    images_path = DirectoryManager.get_diary_images_directory("minha-viagem")
+    expected_path = tmp_path / ".pilgrim" / "diaries" / "minha-viagem" / "data" / "images"
+    assert images_path == expected_path
+    assert (tmp_path / ".pilgrim" / "diaries").exists()
+
+@patch('shutil.copy2')
+@patch('pathlib.Path.home')
+def test_get_database_path_handles_migration_error(mock_home, mock_copy, tmp_path: Path, monkeypatch):
+    fake_home_dir = tmp_path / "home"
+    fake_project_dir = tmp_path / "project"
+    fake_home_dir.mkdir()
+    fake_project_dir.mkdir()
+    (fake_project_dir / "database.db").touch()
+    mock_home.return_value = fake_home_dir
+    mock_copy.side_effect = shutil.Error("O disco está cheio!")
+    monkeypatch.chdir(fake_project_dir)
+    with pytest.raises(RuntimeError, match="Failed to migrate database"):
+        DirectoryManager.get_database_path()
+    mock_copy.assert_called_once()