Add the tests for the update on photo service

# Conflicts:
#	tests/conftest.py
#	tests/service/test_photo_service.py

src/pilgrim/models/photo.py

@@ -25,7 +25,8 @@ class Photo(Base):
         back_populates="photos"
     )
 
-    fk_travel_diary_id = Column(Integer, ForeignKey("travel_diaries.id"),nullable=False)
+    fk_travel_diary_id = Column(Integer, ForeignKey("travel_diaries.id"), nullable=False)
+    travel_diary = relationship("TravelDiary", back_populates="photos")
     __table_args__ = (
         Index('idx_photo_hash_diary', 'hash', 'fk_travel_diary_id'),
     )

src/pilgrim/models/travel_diary.py

@@ -13,6 +13,7 @@ class TravelDiary(Base):
     name = Column(String, nullable=False)
     directory_name = Column(String, nullable=False, unique=True)
     entries = relationship("Entry", back_populates="travel_diary", cascade="all, delete-orphan")
+    photos = relationship("Photo", back_populates="travel_diary", cascade="all, delete-orphan")
 
     __table_args__ = (
         UniqueConstraint('directory_name', name='uq_travel_diary_directory_name'),

tests/conftest.py

@@ -4,6 +4,7 @@ from sqlalchemy.orm import sessionmaker
 
 from pilgrim.database import Base
 from pilgrim.models.travel_diary import TravelDiary
+from pilgrim.models.photo import Photo
 
 # Todos os imports necessários para as fixtures devem estar aqui
 # ...
@@ -34,3 +35,30 @@ def session_with_one_diary(db_session):
     db_session.commit()
     db_session.refresh(diary)
     return db_session, diary
+
+
+@pytest.fixture
+def session_with_photos(session_with_one_diary):
+    session, diary = session_with_one_diary
+
+    # Usamos a mesma raiz de diretório que o mock do teste espera
+    diaries_root = "/fake/diaries_root"
+
+    photo1 = Photo(
+        # CORREÇÃO: O caminho agora inclui a raiz e a subpasta 'images'
+        filepath=f"{diaries_root}/{diary.directory_name}/images/p1.jpg",
+        name="Foto 1",
+        photo_hash="hash1",
+        fk_travel_diary_id=diary.id
+    )
+    photo2 = Photo(
+        filepath=f"{diaries_root}/{diary.directory_name}/images/p2.jpg",
+        name="Foto 2",
+        photo_hash="hash2",
+        fk_travel_diary_id=diary.id
+    )
+
+    session.add_all([photo1, photo2])
+    session.commit()
+
+    return session, [photo1, photo2]

tests/service/test_entry_service.py

@@ -0,0 +1,269 @@
+from re import search
+
+import pytest
+from datetime import datetime
+from unittest.mock import Mock
+from sqlalchemy import create_engine
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import sessionmaker
+
+from pilgrim.database import Base
+from pilgrim.models.travel_diary import TravelDiary
+from pilgrim.models.entry import Entry
+from pilgrim.models.photo import Photo
+
+from pilgrim.service.entry_service import EntryService
+
+
+
+@pytest.fixture
+def session_with_an_entry(populated_db_session):
+    session = populated_db_session
+    initial_entry = Entry(
+        title="Título Original",
+        text="Texto original.",
+        date=datetime(2025, 1, 1),
+        travel_diary_id=1
+    )
+    session.add(initial_entry)
+    session.commit()
+    return session, initial_entry.id
+
+@pytest.fixture
+def session_with_multiple_entries(populated_db_session):
+    """Fixture que cria um diário e duas entradas para ele."""
+    session = populated_db_session
+
+    entry1 = Entry(title="Entrada 1", text="Texto 1", date=datetime(2025, 1, 1), travel_diary_id=1)
+    entry2 = Entry(title="Entrada 2", text="Texto 2", date=datetime(2025, 1, 2), travel_diary_id=1)
+
+    session.add_all([entry1, entry2])
+    session.commit()
+
+    return session
+
+def test_create_entry_successfully(populated_db_session):
+    session = populated_db_session
+    service = EntryService(session)
+    diary_id = 1  # Sabemos que o ID é 1 por causa da nossa fixture
+    title = "Primeiro Dia na Praia"
+    text = "O dia foi ensolarado e o mar estava ótimo."
+    date = datetime(2025, 7, 20)
+    photos = [Photo(filepath="/path/to/photo1.jpg",name="Photo 1",photo_hash="hash_12345678",fk_travel_diary_id=diary_id), Photo(filepath="/path/to/photo2.jpg",name="Photo 1",photo_hash="hash_87654321",fk_travel_diary_id=diary_id)]
+    created_entry = service.create(
+        travel_diary_id=diary_id,
+        title=title,
+        text=text,
+        date=date,
+        photos=photos
+    )
+    assert created_entry is not None
+    assert created_entry.id is not None  # Garante que foi salvo no BD e tem um ID
+    assert created_entry.title == title
+    assert created_entry.text == text
+    assert len(created_entry.photos) == 2
+    assert created_entry.photos[0].filepath == "/path/to/photo1.jpg"
+
+    entry_in_db = session.query(Entry).filter_by(id=created_entry.id).one()
+    assert entry_in_db.title == "Primeiro Dia na Praia"
+
+def test_create_entry_fails_when_diary_id_is_invalid(db_session):
+    session = db_session
+    service = EntryService(session)
+    invalid_id = 666
+
+    result = service.create(
+        travel_diary_id=invalid_id,
+        title="Título de Teste",
+        text="Texto de Teste",
+        date=datetime(2025, 7, 20),
+        photos=[]
+    )
+
+    assert result is None
+
+def test_create_entry_successfully_without_photo(populated_db_session):
+    session = populated_db_session
+    service = EntryService(session)
+    diary_id = 1  # Sabemos que o ID é 1 por causa da nossa fixture
+    title = "Primeiro Dia na Praia"
+    text = "O dia foi ensolarado e o mar estava ótimo."
+    date = datetime(2025, 7, 20)
+    photos = []
+    created_entry = service.create(
+        travel_diary_id=diary_id,
+        title=title,
+        text=text,
+        date=date,
+        photos=photos
+    )
+    assert created_entry is not None
+    assert created_entry.id is not None  # Garante que foi salvo no BD e tem um ID
+    assert created_entry.title == title
+    assert created_entry.text == text
+    assert len(created_entry.photos) == 0
+    entry_in_db = session.query(Entry).filter_by(id=created_entry.id).one()
+    assert entry_in_db.title == "Primeiro Dia na Praia"
+
+def test_create_entry_fails_with_null_title(populated_db_session):
+    session = populated_db_session
+    service = EntryService(session)
+    diary_id = 1
+    with pytest.raises(IntegrityError):
+        service.create(
+            travel_diary_id=diary_id,
+            title=None,
+            text="Um texto qualquer.",
+            date=datetime.now(),
+            photos=[]
+        )
+
+def test_create_entry_fails_with_null_date(populated_db_session):
+    session = populated_db_session
+    service = EntryService(session)
+    diary_id = 1
+    with pytest.raises(IntegrityError):
+        service.create(
+            travel_diary_id=diary_id,
+            title="Sabado de sol",
+            text="Um texto qualquer.",
+            date=None,
+            photos=[]
+        )
+
+def test_create_entry_fails_with_null_diary_id(populated_db_session):
+    session = populated_db_session
+    service = EntryService(session)
+    diary_id = 1
+    result = service.create(
+            travel_diary_id=None,
+            title="Sabado de sol",
+            text="Um texto qualquer.",
+            date=datetime.now(),
+            photos=[]
+        )
+    assert result is None
+def test_ready_by_id_successfully(session_with_an_entry):
+    session,_ = session_with_an_entry
+    service = EntryService(session)
+    search_id = 1
+    result = service.read_by_id(search_id)
+    assert result is not None
+def test_ready_by_id_fails_when_id_is_invalid(db_session):
+    session = db_session
+    service = EntryService(session)
+    invalid_id = 666
+    result = service.read_by_id(invalid_id)
+    assert result is None
+
+def test_read_all_returns_all_entries(session_with_multiple_entries):
+    session = session_with_multiple_entries
+    service = EntryService(session)
+    all_entries = service.read_all()
+    assert isinstance(all_entries, list)
+    assert len(all_entries) == 2
+    assert all_entries[0].title == "Entrada 1"
+    assert all_entries[1].title == "Entrada 2"
+
+def test_read_all_returns_empty_list_on_empty_db(db_session):
+    session = db_session
+    service = EntryService(session)
+    all_entries = service.read_all()
+    assert isinstance(all_entries, list)
+    assert len(all_entries) == 0
+
+def test_update_entry_successfully(session_with_an_entry):
+    session, entry_id = session_with_an_entry
+    service = EntryService(session)
+    entry_src = session.query(Entry).filter_by(id=entry_id).one()
+    new_date = datetime(2025, 1, 2)
+    entry_dst = Entry(
+        title="Título Atualizado",
+        text="Texto atualizado.",
+        date=new_date,
+        travel_diary_id=1,  # Mantemos o mesmo travel_diary_id
+        photos=[]
+    )
+    updated_entry = service.update(entry_src, entry_dst)
+    assert updated_entry is not None
+    assert updated_entry.id == entry_id
+    assert updated_entry.title == "Título Atualizado"
+    assert updated_entry.text == "Texto atualizado."
+    entry_in_db = session.query(Entry).filter_by(id=entry_id).one()
+    assert entry_in_db.title == "Título Atualizado"
+
+def test_update_entry_fails_if_entry_does_not_exist(db_session):
+    service = EntryService(db_session)
+    non_existent_entry = Entry(
+        title="dummy",
+        text="dummy",
+        date=datetime.now(),
+        travel_diary_id=1)
+    non_existent_entry.id = 999
+    entry_with_new_data = Entry(title="Novo Título", text="Novo Texto", date=datetime.now(), travel_diary_id=1)
+    result = service.update(non_existent_entry, entry_with_new_data)
+    assert result is None
+
+def test_update_fails_with_null_title(session_with_an_entry):
+    session, entry_id = session_with_an_entry
+    service = EntryService(session)
+    entry_src = session.query(Entry).filter_by(id=entry_id).one()
+    entry_dst = Entry(
+        title=None,
+        text="Texto atualizado.",
+        date=datetime.now(),
+        travel_diary_id=1,
+        photos=[]
+    )
+    with pytest.raises(IntegrityError):
+        service.update(entry_src, entry_dst)
+
+def test_update_fails_with_null_date(session_with_an_entry):
+    session, entry_id = session_with_an_entry
+    service = EntryService(session)
+    entry_src = session.query(Entry).filter_by(id=entry_id).one()
+    entry_dst = Entry(
+        title=entry_src.title,
+        text="Texto atualizado.",
+        date=None,
+        travel_diary_id=1,
+        photos=[]
+    )
+    with pytest.raises(IntegrityError):
+        service.update(entry_src, entry_dst)
+
+def test_update_fails_with_null_diary_id(session_with_an_entry):
+    session, entry_id = session_with_an_entry
+    service = EntryService(session)
+    entry_src = session.query(Entry).filter_by(id=entry_id).one()
+    entry_dst = Entry(
+        title=entry_src.title,
+        text="Texto atualizado.",
+        date=datetime.now(),
+        travel_diary_id=None,
+        photos=[]
+    )
+    with pytest.raises(IntegrityError):
+        service.update(entry_src, entry_dst)
+
+def test_delete_successfully_removes_entry(session_with_an_entry):
+    session, entry_id = session_with_an_entry
+    service = EntryService(session)
+    entry_to_delete = service.read_by_id(entry_id)
+    assert entry_to_delete is not None
+    deleted_entry = service.delete(entry_to_delete)
+    assert deleted_entry is not None
+    assert deleted_entry.id == entry_id
+    entry_in_db = service.read_by_id(entry_id)
+    assert entry_in_db is None
+
+def test_delete_returns_none_if_entry_does_not_exist(db_session):
+    service = EntryService(db_session)
+    non_existent_entry = Entry(
+        title="dummy",
+        text="dummy",
+        date=datetime.now(),
+        travel_diary_id=1)
+    non_existent_entry.id = 999
+    result = service.delete(non_existent_entry)
+    assert result is None

tests/service/test_photo_service.py

@@ -0,0 +1,249 @@
+import pytest
+from pathlib import Path
+
+from pilgrim import TravelDiary
+from pilgrim.service.photo_service import PhotoService
+import hashlib
+from unittest.mock import patch
+from pilgrim.models.photo import Photo
+from pilgrim.utils import DirectoryManager
+
+
+@patch.object(PhotoService, '_copy_photo_to_diary')
+@patch.object(PhotoService, 'hash_file', return_value="fake_hash_123")
+def test_create_photo_successfully(mock_hash, mock_copy, session_with_one_diary):
+    session, diary = session_with_one_diary
+    service = PhotoService(session)
+    fake_source_path = Path("/path/original/imagem.jpg")
+    fake_copied_path = Path(f"~/.pilgrim/diaries/{diary.directory_name}/images/imagem.jpg")
+    mock_copy.return_value = fake_copied_path
+    new_photo = service.create(
+        filepath=fake_source_path,
+        name="Foto da Praia",
+        travel_diary_id=diary.id,
+        caption="Pôr do sol")
+    mock_hash.assert_called_once_with(fake_source_path)
+    mock_copy.assert_called_once_with(fake_source_path, diary)
+    assert new_photo is not None
+    assert new_photo.name == "Foto da Praia"
+    assert new_photo.photo_hash == "fake_hash_123"
+    assert new_photo.filepath == str(fake_copied_path)
+
+def test_hash_file_generates_correct_hash(tmp_path: Path):
+    original_content_bytes = b"um conteudo de teste para o hash"
+    file_on_disk = tmp_path / "test.jpg"
+    file_on_disk.write_bytes(original_content_bytes)
+    hash_from_file = PhotoService.hash_file(file_on_disk)
+    expected_hash_func = hashlib.new('sha3_384')
+    expected_hash_func.update(original_content_bytes)
+    hash_from_memory = expected_hash_func.hexdigest()
+    assert hash_from_file == hash_from_memory
+
+@patch.object(PhotoService, '_copy_photo_to_diary')
+@patch.object(PhotoService, 'hash_file', return_value="hash_ja_existente")
+def test_create_photo_returns_none_if_hash_exists(mock_hash, mock_copy, session_with_one_diary):
+    session, diary = session_with_one_diary
+    existing_photo = Photo(
+        filepath="/path/existente.jpg", name="Foto Antiga",
+        photo_hash="hash_ja_existente", fk_travel_diary_id=diary.id
+    )
+    session.add(existing_photo)
+    session.commit()
+
+    service = PhotoService(session)
+    new_photo = service.create(
+        filepath=Path("/path/novo/arquivo.jpg"),
+        name="Foto Nova",
+        travel_diary_id=diary.id
+    )
+    assert new_photo is None
+    mock_copy.assert_not_called()
+
+def test_read_by_id_successfully(session_with_photos):
+    session, photos = session_with_photos
+    service = PhotoService(session)
+    photo_to_find_id = photos[0].id
+    found_photo = service.read_by_id(photo_to_find_id)
+    assert found_photo is not None
+    assert found_photo.id == photo_to_find_id
+    assert found_photo.name == "Foto 1"
+
+def test_read_by_id_returns_none_for_invalid_id(db_session):
+    service = PhotoService(db_session)
+    result = service.read_by_id(999)
+    assert result is None
+
+def test_read_all_returns_all_photos(session_with_photos):
+    session, _ = session_with_photos
+    service = PhotoService(session)
+    all_photos = service.read_all()
+
+    assert isinstance(all_photos, list)
+    assert len(all_photos) == 2
+    assert all_photos[0].name == "Foto 1"
+    assert all_photos[1].name == "Foto 2"
+
+def test_read_all_returns_empty_list_for_empty_db(db_session):
+    service = PhotoService(db_session)
+    all_photos = service.read_all()
+    assert isinstance(all_photos, list)
+    assert len(all_photos) == 0
+
+def test_check_photo_by_hash_finds_existing_photo(session_with_photos):
+    session, photos = session_with_photos
+    service = PhotoService(session)
+    existing_photo = photos[0]
+    hash_to_find = existing_photo.photo_hash  # "hash1"
+    diary_id = existing_photo.fk_travel_diary_id  # 1
+    found_photo = service.check_photo_by_hash(hash_to_find, diary_id)
+    assert found_photo is not None
+    assert found_photo.id == existing_photo.id
+    assert found_photo.photo_hash == hash_to_find
+
+def test_check_photo_by_hash_returns_none_when_not_found(session_with_photos):
+    session, photos = session_with_photos
+    service = PhotoService(session)
+    existing_hash = photos[0].photo_hash  # "hash1"
+    existing_diary_id = photos[0].fk_travel_diary_id  # 1
+    result1 = service.check_photo_by_hash("hash_inexistente", existing_diary_id)
+    assert result1 is None
+    invalid_diary_id = 999
+    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")
+def test_delete_photo_successfully(mock_get_root, mock_exists, mock_unlink, session_with_photos):
+    session, photos = session_with_photos
+    service = PhotoService(session)
+    photo_to_delete = photos[0]
+    photo_id = photo_to_delete.id
+    mock_exists.return_value = True
+    deleted_photo_data = service.delete(photo_to_delete)
+    mock_unlink.assert_called_once()
+    assert deleted_photo_data is not None
+    assert deleted_photo_data.id == photo_id
+    photo_in_db = service.read_by_id(photo_id)
+    assert photo_in_db is None
+
+@patch('pathlib.Path.unlink')
+def test_delete_returns_none_for_non_existent_photo(mock_unlink, db_session):
+    service = PhotoService(db_session)
+    non_existent_photo = Photo(
+        filepath="/fake/path.jpg", name="dummy",
+        photo_hash="dummy_hash", fk_travel_diary_id=1
+    )
+    non_existent_photo.id = 999
+    result = service.delete(non_existent_photo)
+    assert result is None
+    mock_unlink.assert_not_called()
+

tests/test_database.py

@@ -0,0 +1,40 @@
+import pytest
+from unittest.mock import Mock  # A ferramenta para criar nosso "dublê"
+from pathlib import Path
+from sqlalchemy import inspect, Column, Integer, String
+from sqlalchemy.orm import Session
+
+from pilgrim.database import Database,Base
+
+class MockUser(Base):
+    __tablename__ = 'mock_users'
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+
+@pytest.fixture
+def db_instance(tmp_path: Path):
+    fake_db_path = tmp_path / "test_pilgrim.db"
+    mock_config_manager = Mock()
+    mock_config_manager.database_url = str(fake_db_path)
+    db = Database(mock_config_manager)
+    return db, fake_db_path
+
+def test_create_database(db_instance):
+    db, fake_db_path = db_instance
+    db.create()
+    assert fake_db_path.exists()
+
+def test_table_creation(db_instance):
+    db, _ = db_instance
+    db.create()
+    inspector = inspect(db.engine)
+    assert "mock_users" in inspector.get_table_names()
+
+def test_session_returned_corectly(db_instance):
+    db, _ = db_instance
+    session = db.session()
+    assert isinstance(session, Session)
+    session.close()
+
+
+