ietm64/LoreMind
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mise en place de la possibilité de supprimer des lores / campagnes d'un seul coup

Browse Source
This commit is contained in:
IETM_FIXE\ietm6
2026-04-23 11:51:03 +02:00
parent 84ccdd53ad
commit 96bc5de942
15 changed files with 585 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
core/src/main/java/com/loremind/application/campaigncontext/CampaignService.java
View File

@@ -1,8 +1,15 @@
package com.loremind.application.campaigncontext;
import com.loremind.domain.campaigncontext.Arc;
import com.loremind.domain.campaigncontext.Campaign;
import com.loremind.domain.campaigncontext.Chapter;
import com.loremind.domain.campaigncontext.ports.ArcRepository;
import com.loremind.domain.campaigncontext.ports.CampaignRepository;
import com.loremind.domain.campaigncontext.ports.ChapterRepository;
import com.loremind.domain.campaigncontext.ports.CharacterRepository;
import com.loremind.domain.campaigncontext.ports.SceneRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Optional;
@@ -16,9 +23,22 @@ import java.util.Optional;
public class CampaignService {
private final CampaignRepository campaignRepository;
private final ArcRepository arcRepository;
private final ChapterRepository chapterRepository;
private final SceneRepository sceneRepository;
private final CharacterRepository characterRepository;
public CampaignService(CampaignRepository campaignRepository) {
public CampaignService(
CampaignRepository campaignRepository,
ArcRepository arcRepository,
ChapterRepository chapterRepository,
SceneRepository sceneRepository,
CharacterRepository characterRepository) {
this.campaignRepository = campaignRepository;
this.arcRepository = arcRepository;
this.chapterRepository = chapterRepository;
this.sceneRepository = sceneRepository;
this.characterRepository = characterRepository;
}
/**
@@ -30,6 +50,12 @@ public class CampaignService {
*/
public record CampaignData(String name, String description, String loreId, String gameSystemId) {}
/**
* Compte des entités qui seront supprimées en cascade si la campagne est effacée.
* Utilisé par l'UI pour afficher un récapitulatif dans le dialogue de confirmation.
*/
public record DeletionImpact(int arcs, int chapters, int scenes, int characters) {}
public Campaign createCampaign(CampaignData data) {
Campaign campaign = Campaign.builder()
.name(data.name())
@@ -71,7 +97,48 @@ public class CampaignService {
return (id == null || id.isBlank()) ? null : id;
}
/**
* Calcule l'impact d'une suppression en cascade : nombre d'arcs, chapitres,
* scènes et personnages qui disparaîtront avec la campagne. Utilisé par l'UI
* pour afficher "X arcs, Y chapitres, Z scènes seront supprimés".
*/
public DeletionImpact getDeletionImpact(String id) {
List<Arc> arcs = arcRepository.findByCampaignId(id);
int chapterTotal = 0;
int sceneTotal = 0;
for (Arc arc : arcs) {
List<Chapter> chapters = chapterRepository.findByArcId(arc.getId());
chapterTotal += chapters.size();
for (Chapter chapter : chapters) {
sceneTotal += sceneRepository.findByChapterId(chapter.getId()).size();
}
}
int characterTotal = characterRepository.findByCampaignId(id).size();
return new DeletionImpact(arcs.size(), chapterTotal, sceneTotal, characterTotal);
}
/**
* Supprime la campagne et toutes ses entités dépendantes (arcs → chapitres →
* scènes, plus les personnages). L'opération est transactionnelle : soit
* tout disparaît, soit rien ne change. Les FKs applicatives n'ayant pas
* de contrainte CASCADE au niveau DB, on orchestre la cascade ici.
*/
@Transactional
public void deleteCampaign(String id) {
List<Arc> arcs = arcRepository.findByCampaignId(id);
for (Arc arc : arcs) {
List<Chapter> chapters = chapterRepository.findByArcId(arc.getId());
for (Chapter chapter : chapters) {
for (var scene : sceneRepository.findByChapterId(chapter.getId())) {
sceneRepository.deleteById(scene.getId());
}
chapterRepository.deleteById(chapter.getId());
}
arcRepository.deleteById(arc.getId());
}
for (var character : characterRepository.findByCampaignId(id)) {
characterRepository.deleteById(character.getId());
}
campaignRepository.deleteById(id);
}

72
core/src/main/java/com/loremind/application/lorecontext/LoreNodeService.java
View File

@@ -1,9 +1,13 @@
package com.loremind.application.lorecontext;
import com.loremind.domain.lorecontext.LoreNode;
import com.loremind.domain.lorecontext.Page;
import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
import com.loremind.domain.lorecontext.ports.PageRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
@@ -16,11 +20,20 @@ import java.util.Optional;
public class LoreNodeService {
private final LoreNodeRepository loreNodeRepository;
private final PageRepository pageRepository;
public LoreNodeService(LoreNodeRepository loreNodeRepository) {
public LoreNodeService(LoreNodeRepository loreNodeRepository, PageRepository pageRepository) {
this.loreNodeRepository = loreNodeRepository;
this.pageRepository = pageRepository;
}
/**
* Compte des entités qui seront supprimées en cascade si le dossier est effacé :
* le dossier lui-même n'est pas compté, seuls les descendants (sous-dossiers
* récursifs + pages de l'ensemble du sous-arbre).
*/
public record DeletionImpact(int folders, int pages) {}
/**
* Crée un LoreNode (dossier) à partir d'un "objet changes" porteur des valeurs
* souhaitées (pattern Parameter Object) : évite les signatures qui gonflent
@@ -68,7 +81,64 @@ public class LoreNodeService {
return loreNodeRepository.save(existing);
}
/**
* Calcule l'impact d'une suppression en cascade : nombre de sous-dossiers
* (récursif, sans compter la racine) et de pages dans l'ensemble du sous-arbre.
*/
public DeletionImpact getDeletionImpact(String id) {
List<LoreNode> descendants = collectDescendants(id);
int pageTotal = pageRepository.findByNodeId(id).size();
for (LoreNode descendant : descendants) {
pageTotal += pageRepository.findByNodeId(descendant.getId()).size();
}
return new DeletionImpact(descendants.size(), pageTotal);
}
/**
* Supprime le dossier et tout son sous-arbre (sous-dossiers récursifs + pages).
* Suppression en profondeur d'abord (feuilles → racine) pour limiter les
* références orphelines en cours de transaction. Les FKs applicatives n'ayant
* pas de CASCADE en DB, on orchestre la descente ici.
*/
@Transactional
public void deleteLoreNode(String id) {
List<LoreNode> descendants = collectDescendants(id);
// Descendants retournés en ordre BFS (haut → bas) : on inverse pour
// supprimer les feuilles en premier, puis on finit par la racine.
for (int i = descendants.size() - 1; i >= 0; i--) {
String descendantId = descendants.get(i).getId();
deletePagesOfNode(descendantId);
loreNodeRepository.deleteById(descendantId);
}
deletePagesOfNode(id);
loreNodeRepository.deleteById(id);
}
private void deletePagesOfNode(String nodeId) {
for (Page page : pageRepository.findByNodeId(nodeId)) {
pageRepository.deleteById(page.getId());
}
}
/**
* Retourne tous les descendants (hors racine) d'un dossier, en ordre BFS.
* Parcours itératif pour éviter tout risque de débordement de pile sur
* une arborescence profonde malicieuse.
*/
private List<LoreNode> collectDescendants(String rootId) {
List<LoreNode> result = new ArrayList<>();
List<String> frontier = new ArrayList<>();
frontier.add(rootId);
while (!frontier.isEmpty()) {
List<String> nextFrontier = new ArrayList<>();
for (String parentId : frontier) {
for (LoreNode child : loreNodeRepository.findByParentId(parentId)) {
result.add(child);
nextFrontier.add(child.getId());
}
}
frontier = nextFrontier;
}
return result;
}
}

71
core/src/main/java/com/loremind/application/lorecontext/LoreService.java
View File

@@ -1,10 +1,17 @@
package com.loremind.application.lorecontext;
import com.loremind.domain.campaigncontext.Campaign;
import com.loremind.domain.campaigncontext.ports.CampaignRepository;
import com.loremind.domain.lorecontext.Lore;
import com.loremind.domain.lorecontext.LoreNode;
import com.loremind.domain.lorecontext.Page;
import com.loremind.domain.lorecontext.Template;
import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
import com.loremind.domain.lorecontext.ports.LoreRepository;
import com.loremind.domain.lorecontext.ports.PageRepository;
import com.loremind.domain.lorecontext.ports.TemplateRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Optional;
@@ -26,15 +33,28 @@ public class LoreService {
private final LoreRepository loreRepository;
private final LoreNodeRepository loreNodeRepository;
private final PageRepository pageRepository;
private final TemplateRepository templateRepository;
private final CampaignRepository campaignRepository;
public LoreService(LoreRepository loreRepository,
LoreNodeRepository loreNodeRepository,
PageRepository pageRepository) {
PageRepository pageRepository,
TemplateRepository templateRepository,
CampaignRepository campaignRepository) {
this.loreRepository = loreRepository;
this.loreNodeRepository = loreNodeRepository;
this.pageRepository = pageRepository;
this.templateRepository = templateRepository;
this.campaignRepository = campaignRepository;
}
/**
* Compte des entités qui seront supprimées / détachées en cascade si le Lore
* est effacé. `detachedCampaigns` : campagnes qui perdront leur référence à
* ce Lore (leur loreId sera nullé) mais resteront présentes.
*/
public record DeletionImpact(int folders, int pages, int templates, int detachedCampaigns) {}
public Lore createLore(String name, String description) {
Lore lore = Lore.builder()
.name(name)
@@ -76,14 +96,61 @@ public class LoreService {
if (existingLore.isEmpty()) {
throw new IllegalArgumentException("Lore non trouvé avec l'ID: " + id);
}
Lore lore = existingLore.get();
lore.setName(name);
lore.setDescription(description);
return loreRepository.save(lore);
}
/**
* Calcule l'impact d'une suppression de Lore en cascade : dossiers + pages
* + templates supprimés, et campagnes qui seront détachées (loreId → null
* sans être supprimées, car une campagne peut vivre sans univers).
*/
public DeletionImpact getDeletionImpact(String id) {
int folders = (int) loreNodeRepository.countByLoreId(id);
int pages = (int) pageRepository.countByLoreId(id);
int templates = templateRepository.findByLoreId(id).size();
int detached = countCampaignsReferencingLore(id);
return new DeletionImpact(folders, pages, templates, detached);
}
/**
* Supprime le Lore et toutes ses entités dépendantes (dossiers, pages, templates).
* Les campagnes qui référençaient ce Lore sont conservées — leur loreId est
* mis à null (une campagne peut légitimement exister sans univers associé).
* Opération transactionnelle : atomique.
*/
@Transactional
public void deleteLore(String id) {
// Pages d'abord : elles référencent nodeId ET loreId, on les supprime
// globalement via loreId pour éviter d'en rater une rattachée à un
// node orphelin (ne devrait pas arriver, mais ceinture+bretelles).
for (Page page : pageRepository.findByLoreId(id)) {
pageRepository.deleteById(page.getId());
}
for (LoreNode node : loreNodeRepository.findByLoreId(id)) {
loreNodeRepository.deleteById(node.getId());
}
for (Template template : templateRepository.findByLoreId(id)) {
templateRepository.deleteById(template.getId());
}
// Détache les campagnes : on garde la campagne, on nulle juste la référence.
for (Campaign campaign : campaignRepository.findAll()) {
if (id.equals(campaign.getLoreId())) {
campaign.setLoreId(null);
campaignRepository.save(campaign);
}
}
loreRepository.deleteById(id);
}
private int countCampaignsReferencingLore(String id) {
int count = 0;
for (Campaign campaign : campaignRepository.findAll()) {
if (id.equals(campaign.getLoreId())) count++;
}
return count;
}
}

12
core/src/main/java/com/loremind/infrastructure/web/controller/CampaignController.java
View File

@@ -74,4 +74,16 @@ public class CampaignController {
campaignService.deleteCampaign(id);
return ResponseEntity.noContent().build();
}
/**
* Récapitulatif des entités qui seront supprimées en cascade : utilisé par
* l'UI pour afficher "X arcs, Y chapitres, Z scènes..." dans la confirmation.
*/
@GetMapping("/{id}/deletion-impact")
public ResponseEntity<CampaignService.DeletionImpact> getDeletionImpact(@PathVariable String id) {
if (!campaignService.campaignExists(id)) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(campaignService.getDeletionImpact(id));
}
}

13
core/src/main/java/com/loremind/infrastructure/web/controller/LoreController.java
View File

@@ -69,4 +69,17 @@ public class LoreController {
loreService.deleteLore(id);
return ResponseEntity.noContent().build();
}
/**
* Récapitulatif des entités qui seront supprimées / détachées en cascade.
* Utilisé par l'UI pour afficher "X dossiers, Y pages, Z templates,
* N campagne(s) détachée(s)" dans la confirmation.
*/
@GetMapping("/{id}/deletion-impact")
public ResponseEntity<LoreService.DeletionImpact> getDeletionImpact(@PathVariable String id) {
if (loreService.getLoreById(id).isEmpty()) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(loreService.getDeletionImpact(id));
}
}

12
core/src/main/java/com/loremind/infrastructure/web/controller/LoreNodeController.java
View File

@@ -97,4 +97,16 @@ public class LoreNodeController {
loreNodeService.deleteLoreNode(id);
return ResponseEntity.noContent().build();
}
/**
* Récapitulatif des entités qui seront supprimées en cascade : utilisé par
* l'UI pour afficher "X sous-dossiers, Y pages..." dans la confirmation.
*/
@GetMapping("/{id}/deletion-impact")
public ResponseEntity<LoreNodeService.DeletionImpact> getDeletionImpact(@PathVariable String id) {
if (loreNodeService.getLoreNodeById(id).isEmpty()) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(loreNodeService.getDeletionImpact(id));
}
}

84
core/src/test/java/com/loremind/application/campaigncontext/CampaignServiceTest.java
View File

@@ -1,7 +1,15 @@
package com.loremind.application.campaigncontext;
import com.loremind.domain.campaigncontext.Arc;
import com.loremind.domain.campaigncontext.Campaign;
import com.loremind.domain.campaigncontext.Chapter;
import com.loremind.domain.campaigncontext.Character;
import com.loremind.domain.campaigncontext.Scene;
import com.loremind.domain.campaigncontext.ports.ArcRepository;
import com.loremind.domain.campaigncontext.ports.CampaignRepository;
import com.loremind.domain.campaigncontext.ports.ChapterRepository;
import com.loremind.domain.campaigncontext.ports.CharacterRepository;
import com.loremind.domain.campaigncontext.ports.SceneRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -27,6 +35,14 @@ public class CampaignServiceTest {
@Mock
private CampaignRepository campaignRepository;
@Mock
private ArcRepository arcRepository;
@Mock
private ChapterRepository chapterRepository;
@Mock
private SceneRepository sceneRepository;
@Mock
private CharacterRepository characterRepository;
@InjectMocks
private CampaignService campaignService;
@@ -196,15 +212,75 @@ public class CampaignServiceTest {
}
@Test
void testDeleteCampaign() {
// Arrange
doNothing().when(campaignRepository).deleteById("campaign-1");
void testDeleteCampaign_EmptyCampaign() {
// Arrange : aucune dépendance ; Mockito renvoie List.of() par défaut.
// Act
campaignService.deleteCampaign("campaign-1");
// Assert
verify(campaignRepository, times(1)).deleteById("campaign-1");
verify(arcRepository, never()).deleteById(anyString());
verify(chapterRepository, never()).deleteById(anyString());
verify(sceneRepository, never()).deleteById(anyString());
verify(characterRepository, never()).deleteById(anyString());
}
@Test
void testDeleteCampaign_CascadesArcsChaptersScenes() {
// Arrange : campagne avec 1 arc → 1 chapitre → 2 scènes.
Arc arc = Arc.builder().id("arc-1").campaignId("campaign-1").name("Arc 1").build();
Chapter chapter = Chapter.builder().id("chap-1").arcId("arc-1").name("Chap 1").build();
Scene scene1 = Scene.builder().id("scene-1").chapterId("chap-1").name("Scene 1").build();
Scene scene2 = Scene.builder().id("scene-2").chapterId("chap-1").name("Scene 2").build();
when(arcRepository.findByCampaignId("campaign-1")).thenReturn(List.of(arc));
when(chapterRepository.findByArcId("arc-1")).thenReturn(List.of(chapter));
when(sceneRepository.findByChapterId("chap-1")).thenReturn(List.of(scene1, scene2));
// Act
campaignService.deleteCampaign("campaign-1");
// Assert : tout disparaît, dans l'ordre feuilles → racine.
verify(sceneRepository).deleteById("scene-1");
verify(sceneRepository).deleteById("scene-2");
verify(chapterRepository).deleteById("chap-1");
verify(arcRepository).deleteById("arc-1");
verify(campaignRepository).deleteById("campaign-1");
}
@Test
void testDeleteCampaign_CascadesCharacters() {
Character pc = Character.builder().id("char-1").campaignId("campaign-1").name("Alric").build();
when(characterRepository.findByCampaignId("campaign-1")).thenReturn(List.of(pc));
campaignService.deleteCampaign("campaign-1");
verify(characterRepository).deleteById("char-1");
verify(campaignRepository).deleteById("campaign-1");
}
@Test
void testGetDeletionImpact() {
Arc arc = Arc.builder().id("arc-1").campaignId("campaign-1").name("Arc 1").build();
Chapter c1 = Chapter.builder().id("chap-1").arcId("arc-1").name("C1").build();
Chapter c2 = Chapter.builder().id("chap-2").arcId("arc-1").name("C2").build();
Scene s1 = Scene.builder().id("s-1").chapterId("chap-1").name("S1").build();
Scene s2 = Scene.builder().id("s-2").chapterId("chap-2").name("S2").build();
Scene s3 = Scene.builder().id("s-3").chapterId("chap-2").name("S3").build();
Character pc = Character.builder().id("char-1").campaignId("campaign-1").name("Alric").build();
when(arcRepository.findByCampaignId("campaign-1")).thenReturn(List.of(arc));
when(chapterRepository.findByArcId("arc-1")).thenReturn(List.of(c1, c2));
when(sceneRepository.findByChapterId("chap-1")).thenReturn(List.of(s1));
when(sceneRepository.findByChapterId("chap-2")).thenReturn(List.of(s2, s3));
when(characterRepository.findByCampaignId("campaign-1")).thenReturn(List.of(pc));
CampaignService.DeletionImpact impact = campaignService.getDeletionImpact("campaign-1");
assertEquals(1, impact.arcs());
assertEquals(2, impact.chapters());
assertEquals(3, impact.scenes());
assertEquals(1, impact.characters());
}
@Test

64
core/src/test/java/com/loremind/application/lorecontext/LoreNodeServiceTest.java
View File

@@ -1,7 +1,9 @@
package com.loremind.application.lorecontext;
import com.loremind.domain.lorecontext.LoreNode;
import com.loremind.domain.lorecontext.Page;
import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
import com.loremind.domain.lorecontext.ports.PageRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -15,6 +17,7 @@ import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.*;
/**
@@ -26,6 +29,7 @@ import static org.mockito.Mockito.*;
public class LoreNodeServiceTest {
@Mock private LoreNodeRepository loreNodeRepository;
@Mock private PageRepository pageRepository;
@InjectMocks private LoreNodeService loreNodeService;
@@ -118,8 +122,66 @@ public class LoreNodeServiceTest {
}
@Test
void testDelete() {
void testDelete_LeafFolder() {
// Aucun descendant, aucune page : seul le dossier est supprimé.
loreNodeService.deleteLoreNode("n-1");
verify(loreNodeRepository).deleteById("n-1");
verify(pageRepository, never()).deleteById(anyString());
}
@Test
void testDelete_CascadesPagesOfRoot() {
Page p1 = Page.builder().id("p-1").nodeId("n-1").title("P1").build();
Page p2 = Page.builder().id("p-2").nodeId("n-1").title("P2").build();
when(pageRepository.findByNodeId("n-1")).thenReturn(List.of(p1, p2));
loreNodeService.deleteLoreNode("n-1");
verify(pageRepository).deleteById("p-1");
verify(pageRepository).deleteById("p-2");
verify(loreNodeRepository).deleteById("n-1");
}
@Test
void testDelete_CascadesSubfoldersRecursive() {
// n-1 → n-1a → n-1a1 ; chaque feuille a une page.
LoreNode mid = LoreNode.builder().id("n-1a").parentId("n-1").loreId("lore-1").name("mid").build();
LoreNode leaf = LoreNode.builder().id("n-1a1").parentId("n-1a").loreId("lore-1").name("leaf").build();
Page pageOnLeaf = Page.builder().id("p-leaf").nodeId("n-1a1").title("P").build();
when(loreNodeRepository.findByParentId("n-1")).thenReturn(List.of(mid));
when(loreNodeRepository.findByParentId("n-1a")).thenReturn(List.of(leaf));
when(pageRepository.findByNodeId("n-1a1")).thenReturn(List.of(pageOnLeaf));
loreNodeService.deleteLoreNode("n-1");
// Feuilles d'abord (pages puis dossier leaf), puis mid, puis la racine.
verify(pageRepository).deleteById("p-leaf");
verify(loreNodeRepository).deleteById("n-1a1");
verify(loreNodeRepository).deleteById("n-1a");
verify(loreNodeRepository).deleteById("n-1");
}
@Test
void testGetDeletionImpact_CountsSubfoldersAndPages() {
LoreNode sub1 = LoreNode.builder().id("s-1").parentId("n-1").loreId("lore-1").name("s1").build();
LoreNode sub2 = LoreNode.builder().id("s-2").parentId("n-1").loreId("lore-1").name("s2").build();
LoreNode subsub = LoreNode.builder().id("s-1a").parentId("s-1").loreId("lore-1").name("s1a").build();
Page p1 = Page.builder().id("p-1").nodeId("n-1").title("P1").build();
Page p2 = Page.builder().id("p-2").nodeId("s-1").title("P2").build();
Page p3 = Page.builder().id("p-3").nodeId("s-1a").title("P3").build();
when(loreNodeRepository.findByParentId("n-1")).thenReturn(List.of(sub1, sub2));
when(loreNodeRepository.findByParentId("s-1")).thenReturn(List.of(subsub));
when(pageRepository.findByNodeId("n-1")).thenReturn(List.of(p1));
when(pageRepository.findByNodeId("s-1")).thenReturn(List.of(p2));
when(pageRepository.findByNodeId("s-2")).thenReturn(List.of());
when(pageRepository.findByNodeId("s-1a")).thenReturn(List.of(p3));
LoreNodeService.DeletionImpact impact = loreNodeService.getDeletionImpact("n-1");
// 3 sous-dossiers (sub1, sub2, subsub) — on ne compte pas la racine n-1.
assertEquals(3, impact.folders());
assertEquals(3, impact.pages());
}
}

70
core/src/test/java/com/loremind/application/lorecontext/LoreServiceTest.java
View File

@@ -1,9 +1,15 @@
package com.loremind.application.lorecontext;
import com.loremind.domain.campaigncontext.Campaign;
import com.loremind.domain.campaigncontext.ports.CampaignRepository;
import com.loremind.domain.lorecontext.Lore;
import com.loremind.domain.lorecontext.LoreNode;
import com.loremind.domain.lorecontext.Page;
import com.loremind.domain.lorecontext.Template;
import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
import com.loremind.domain.lorecontext.ports.LoreRepository;
import com.loremind.domain.lorecontext.ports.PageRepository;
import com.loremind.domain.lorecontext.ports.TemplateRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -17,6 +23,7 @@ import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.*;
/**
@@ -30,6 +37,8 @@ public class LoreServiceTest {
@Mock private LoreRepository loreRepository;
@Mock private LoreNodeRepository loreNodeRepository;
@Mock private PageRepository pageRepository;
@Mock private TemplateRepository templateRepository;
@Mock private CampaignRepository campaignRepository;
@InjectMocks private LoreService loreService;
@@ -134,8 +143,67 @@ public class LoreServiceTest {
}
@Test
void testDeleteLore_DelegatesToRepository() {
void testDeleteLore_EmptyLore() {
// Aucun dossier / page / template / campagne : seul le Lore est supprimé.
loreService.deleteLore("lore-1");
verify(loreRepository).deleteById("lore-1");
verify(loreNodeRepository, never()).deleteById(anyString());
verify(pageRepository, never()).deleteById(anyString());
verify(templateRepository, never()).deleteById(anyString());
}
@Test
void testDeleteLore_CascadesFoldersPagesTemplates() {
LoreNode node = LoreNode.builder().id("n-1").loreId("lore-1").name("F").build();
Page page = Page.builder().id("p-1").loreId("lore-1").nodeId("n-1").title("P").build();
Template template = Template.builder().id("t-1").loreId("lore-1").name("T").build();
when(pageRepository.findByLoreId("lore-1")).thenReturn(List.of(page));
when(loreNodeRepository.findByLoreId("lore-1")).thenReturn(List.of(node));
when(templateRepository.findByLoreId("lore-1")).thenReturn(List.of(template));
loreService.deleteLore("lore-1");
verify(pageRepository).deleteById("p-1");
verify(loreNodeRepository).deleteById("n-1");
verify(templateRepository).deleteById("t-1");
verify(loreRepository).deleteById("lore-1");
}
@Test
void testDeleteLore_DetachesCampaignsInsteadOfDeleting() {
Campaign attached = Campaign.builder().id("c-1").loreId("lore-1").name("C1").build();
Campaign other = Campaign.builder().id("c-2").loreId("lore-other").name("C2").build();
Campaign orphan = Campaign.builder().id("c-3").loreId(null).name("C3").build();
when(campaignRepository.findAll()).thenReturn(List.of(attached, other, orphan));
when(campaignRepository.save(any(Campaign.class))).thenAnswer(inv -> inv.getArgument(0));
loreService.deleteLore("lore-1");
// Seule la campagne attachée est re-sauvegardée (avec loreId=null).
ArgumentCaptor<Campaign> captor = ArgumentCaptor.forClass(Campaign.class);
verify(campaignRepository, times(1)).save(captor.capture());
assertEquals("c-1", captor.getValue().getId());
assertNull(captor.getValue().getLoreId());
// Aucune campagne n'est supprimée.
verify(campaignRepository, never()).deleteById(anyString());
}
@Test
void testGetDeletionImpact() {
Template t1 = Template.builder().id("t-1").loreId("lore-1").name("T").build();
Campaign attached = Campaign.builder().id("c-1").loreId("lore-1").name("C").build();
Campaign unrelated = Campaign.builder().id("c-2").loreId("lore-other").name("C2").build();
when(loreNodeRepository.countByLoreId("lore-1")).thenReturn(4L);
when(pageRepository.countByLoreId("lore-1")).thenReturn(12L);
when(templateRepository.findByLoreId("lore-1")).thenReturn(List.of(t1));
when(campaignRepository.findAll()).thenReturn(List.of(attached, unrelated));
LoreService.DeletionImpact impact = loreService.getDeletionImpact("lore-1");
assertEquals(4, impact.folders());
assertEquals(12, impact.pages());
assertEquals(1, impact.templates());
assertEquals(1, impact.detachedCampaigns());
}
}