colgora/Mangarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: analyse import + all tests fixed

Browse Source
This commit is contained in:
ext.jeremy.guillot@maxicoffee.domains
2025-10-15 16:14:15 +02:00
parent fbe9619224
commit 3170a7c60e
74 changed files with 4318 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
tests/Domain/Manga/Adapter/InMemoryChapterSynchronizationService.php Normal file
View File

@@ -0,0 +1,37 @@
<?php
namespace App\Tests\Domain\Manga\Adapter;
use App\Domain\Manga\Domain\Contract\Service\ChapterSynchronizationServiceInterface;
use App\Domain\Manga\Domain\Model\Manga;
class InMemoryChapterSynchronizationService implements ChapterSynchronizationServiceInterface
{
/** @var array<string, array> */
private array $synchronizedChapters = [];
public function synchronizeChapters(Manga $manga): array
{
$this->synchronizedChapters[$manga->getId()->getValue()] = [
'manga_id' => $manga->getId()->getValue(),
'external_id' => $manga->getExternalId()?->getValue(),
'synchronized_at' => new \DateTimeImmutable()
];
// Retourne les IDs des chapitres synchronisés (simulation)
return ['chapter-1', 'chapter-2'];
}
/**
* @return array<string, array>
*/
public function getSynchronizedChapters(): array
{
return $this->synchronizedChapters;
}
public function clear(): void
{
$this->synchronizedChapters = [];
}
}

8
tests/Domain/Manga/Adapter/InMemoryMangaRepository.php
View File

@@ -128,13 +128,14 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
return null;
}
public function saveChapter(Chapter $chapter): void
public function saveChapter(Chapter $chapter): ChapterId
{
$this->savedChapters[] = $chapter;
if (!isset($this->chapters[$chapter->getMangaId()])) {
$this->chapters[$chapter->getMangaId()] = [];
}
$this->chapters[$chapter->getMangaId()][] = $chapter;
return new ChapterId($chapter->getId());
}
/** @return array<Chapter> */
@@ -160,6 +161,11 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
$manga->getDescription()
];
// Ajouter les slugs alternatifs aux champs de recherche
foreach ($manga->getAlternativeSlugs() as $altSlug) {
$searchableFields[] = $altSlug;
}
foreach ($searchableFields as $field) {
if (str_contains(strtolower($field), strtolower($query))) {
return true;

10
tests/Domain/Manga/Application/CommandHandler/CreateMangaFromMangadexHandlerTest.php
View File

@@ -13,7 +13,7 @@ use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
use App\Tests\Domain\Manga\Adapter\InMemoryMangaProvider;
use App\Tests\Domain\Manga\Adapter\InMemoryMangaRepository;
use App\Tests\Domain\Manga\Adapter\InMemoryImageProcessor;
use App\Tests\Shared\Adapter\InMemoryMessageBus;
use App\Tests\Shared\Adapter\InMemoryEventDispatcher;
use PHPUnit\Framework\TestCase;
class CreateMangaFromMangadexHandlerTest extends TestCase
@@ -22,7 +22,7 @@ class CreateMangaFromMangadexHandlerTest extends TestCase
private InMemoryMangaRepository $repository;
private InMemoryImageProcessor $imageProcessor;
private CreateMangaFromMangadexHandler $handler;
private InMemoryMessageBus $messageBus;
private InMemoryEventDispatcher $eventDispatcher;
protected function setUp(): void
{
$manga = new Manga(
@@ -41,12 +41,12 @@ class CreateMangaFromMangadexHandlerTest extends TestCase
$this->provider = new InMemoryMangaProvider([$manga]);
$this->repository = new InMemoryMangaRepository();
$this->imageProcessor = new InMemoryImageProcessor();
$this->messageBus = new InMemoryMessageBus();
$this->eventDispatcher = new InMemoryEventDispatcher();
$this->handler = new CreateMangaFromMangadexHandler(
$this->provider,
$this->repository,
$this->imageProcessor,
$this->messageBus
$this->eventDispatcher
);
}
@@ -76,4 +76,4 @@ class CreateMangaFromMangadexHandlerTest extends TestCase
// Act
$this->handler->handle($command);
}
}
}

37
tests/Domain/Manga/Application/CommandHandler/FetchMangaChaptersHandlerTest.php
View File

@@ -4,28 +4,29 @@ namespace App\Tests\Domain\Manga\Application\CommandHandler;
use App\Domain\Manga\Application\Command\FetchMangaChapters;
use App\Domain\Manga\Application\CommandHandler\FetchMangaChaptersHandler;
use App\Domain\Manga\Domain\Exception\MangadexApiException;
use App\Domain\Manga\Domain\Model\Manga;
use App\Domain\Manga\Domain\Model\ValueObject\ExternalId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
use App\Tests\Domain\Manga\Adapter\InMemoryMangadexClient;
use App\Tests\Domain\Manga\Adapter\InMemoryChapterSynchronizationService;
use App\Tests\Domain\Manga\Adapter\InMemoryMangaRepository;
use PHPUnit\Framework\TestCase;
class FetchMangaChaptersHandlerTest extends TestCase
{
private InMemoryMangadexClient $mangadexClient;
private InMemoryChapterSynchronizationService $chapterSynchronizationService;
private InMemoryMangaRepository $mangaRepository;
private FetchMangaChaptersHandler $handler;
protected function setUp(): void
{
$this->mangadexClient = new InMemoryMangadexClient();
$this->chapterSynchronizationService = new InMemoryChapterSynchronizationService();
$this->mangaRepository = new InMemoryMangaRepository();
$this->handler = new FetchMangaChaptersHandler(
$this->mangadexClient,
$this->mangaRepository
$this->mangaRepository,
$this->chapterSynchronizationService
);
}
@@ -47,22 +48,12 @@ class FetchMangaChaptersHandlerTest extends TestCase
$this->mangaRepository->save($manga);
$this->mangadexClient->addFeed($externalId, [
[
'id' => 'chapter-1',
'attributes' => [
'chapter' => '1',
'title' => 'Chapter 1',
'volume' => '1',
'translatedLanguage' => 'fr'
]
]
]);
$command = new FetchMangaChapters($mangaId);
$command = new FetchMangaChapters(new MangaId($mangaId));
$this->handler->handle($command);
$this->assertCount(1, $this->mangaRepository->getSavedChapters());
$synchronizedChapters = $this->chapterSynchronizationService->getSynchronizedChapters();
$this->assertCount(1, $synchronizedChapters);
$this->assertArrayHasKey($mangaId, $synchronizedChapters);
}
public function testHandleWithNonExistingManga(): void
@@ -72,7 +63,7 @@ class FetchMangaChaptersHandlerTest extends TestCase
$this->expectException(\RuntimeException::class);
$this->expectExceptionMessage('Manga not found');
$command = new FetchMangaChapters($mangaId);
$command = new FetchMangaChapters(new MangaId($mangaId));
$this->handler->handle($command);
}
@@ -93,10 +84,10 @@ class FetchMangaChaptersHandlerTest extends TestCase
$this->mangaRepository->save($manga);
$this->expectException(\RuntimeException::class);
$this->expectExceptionMessage('Manga has no external ID');
$this->expectException(MangadexApiException::class);
$this->expectExceptionMessage('Manga has no external_id');
$command = new FetchMangaChapters($mangaId);
$command = new FetchMangaChapters(new MangaId($mangaId));
$this->handler->handle($command);
}
}

414
tests/Domain/Manga/Application/QueryHandler/FindMangaMatchByFilenameHandlerTest.php Normal file
View File

@@ -0,0 +1,414 @@
<?php
declare(strict_types=1);
namespace App\Tests\Domain\Manga\Application\QueryHandler;
use App\Domain\Manga\Application\Query\FindMangaMatchByFilename;
use App\Domain\Manga\Application\QueryHandler\FindMangaMatchByFilenameHandler;
use App\Domain\Manga\Domain\Model\Manga;
use App\Domain\Manga\Domain\Model\ValueObject\ImageUrls;
use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
use App\Domain\Manga\Infrastructure\Service\FilenameAnalyzer;
use App\Tests\Domain\Manga\Adapter\InMemoryMangaRepository;
use PHPUnit\Framework\TestCase;
class FindMangaMatchByFilenameHandlerTest extends TestCase
{
private InMemoryMangaRepository $repository;
private FilenameAnalyzer $filenameAnalyzer;
private FindMangaMatchByFilenameHandler $handler;
protected function setUp(): void
{
$this->repository = new InMemoryMangaRepository();
$this->filenameAnalyzer = new FilenameAnalyzer();
$this->handler = new FindMangaMatchByFilenameHandler(
$this->filenameAnalyzer,
$this->repository
);
}
public function test_it_finds_exact_match_by_title(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'One Piece',
slug: 'one-piece'
);
$this->repository->save($manga);
// When
$query = new FindMangaMatchByFilename('one-piece_vol108_ch1094.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertTrue($response->hasMatches());
$this->assertCount(1, $response->matches);
$match = $response->matches[0];
$this->assertEquals('123', $match->id);
$this->assertEquals('One Piece', $match->title);
$this->assertEquals('one-piece', $match->slug);
$this->assertEquals(1094.0, $match->chapterNumber);
$this->assertEquals(108, $match->volumeNumber);
// Vérifier aussi dans la réponse globale
$this->assertEquals(1094.0, $response->chapterNumber);
$this->assertEquals(108, $response->volumeNumber);
$this->assertNotEmpty($response->possibleTitles);
}
public function test_it_returns_empty_matches_when_no_manga_found(): void
{
// Given - no manga in repository
// When
$query = new FindMangaMatchByFilename('unknown-manga_vol1_ch1.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertFalse($response->hasMatches());
$this->assertCount(0, $response->matches);
$this->assertNull($response->getBestMatch());
}
public function test_it_finds_multiple_matches_and_sorts_by_score(): void
{
// Given
$manga1 = $this->createManga(
id: '1',
title: 'One Piece',
slug: 'one-piece'
);
$manga2 = $this->createManga(
id: '2',
title: 'One Piece Z',
slug: 'one-piece-z'
);
$manga3 = $this->createManga(
id: '3',
title: 'The One Piece',
slug: 'the-one-piece'
);
$this->repository->save($manga1);
$this->repository->save($manga2);
$this->repository->save($manga3);
// When
$query = new FindMangaMatchByFilename('one-piece_vol108_ch1094.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertTrue($response->hasMatches());
$this->assertGreaterThanOrEqual(1, count($response->matches));
// Le meilleur match devrait être "One Piece" (correspondance exacte)
$bestMatch = $response->getBestMatch();
$this->assertNotNull($bestMatch);
$this->assertEquals('One Piece', $bestMatch->title);
// Les scores doivent être triés par ordre décroissant
$scores = array_map(fn($match) => $match->matchScore, $response->matches);
$sortedScores = $scores;
rsort($sortedScores);
$this->assertEquals($sortedScores, $scores);
}
public function test_it_extracts_chapter_and_volume_numbers(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'Attack on Titan',
slug: 'attack-on-titan'
);
$this->repository->save($manga);
// When
$query = new FindMangaMatchByFilename('attack-on-titan_vol32_ch130.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertEquals(130.0, $response->chapterNumber);
$this->assertEquals(32, $response->volumeNumber);
// Vérifier que chaque match contient aussi ces informations
foreach ($response->matches as $match) {
$this->assertEquals(130.0, $match->chapterNumber);
$this->assertEquals(32, $match->volumeNumber);
}
}
public function test_it_handles_decimal_chapter_numbers(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'Naruto',
slug: 'naruto'
);
$this->repository->save($manga);
// When
$query = new FindMangaMatchByFilename('naruto_vol50_ch456.5.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertEquals(456.5, $response->chapterNumber);
$this->assertEquals(50, $response->volumeNumber);
// Vérifier que chaque match contient aussi ces informations
foreach ($response->matches as $match) {
$this->assertEquals(456.5, $match->chapterNumber);
$this->assertEquals(50, $match->volumeNumber);
}
}
public function test_it_finds_matches_with_alternative_slugs(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'Shingeki no Kyojin',
slug: 'shingeki-no-kyojin',
alternativeSlugs: ['attack-on-titan', 'aot']
);
$this->repository->save($manga);
// When
$query = new FindMangaMatchByFilename('attack-on-titan_vol1_ch1.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertTrue($response->hasMatches());
$bestMatch = $response->getBestMatch();
$this->assertNotNull($bestMatch);
$this->assertEquals('123', $bestMatch->id);
$this->assertEquals('Shingeki no Kyojin', $bestMatch->title);
}
public function test_it_handles_filename_without_chapter_or_volume(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'One Piece',
slug: 'one-piece'
);
$this->repository->save($manga);
// When
$query = new FindMangaMatchByFilename('one-piece.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertTrue($response->hasMatches());
$this->assertNull($response->chapterNumber);
$this->assertNull($response->volumeNumber);
$bestMatch = $response->getBestMatch();
$this->assertEquals('123', $bestMatch->id);
$this->assertNull($bestMatch->chapterNumber);
$this->assertNull($bestMatch->volumeNumber);
}
public function test_it_finds_single_match_with_unique_id(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'One Piece',
slug: 'one-piece'
);
$this->repository->save($manga);
// When
$query = new FindMangaMatchByFilename('one-piece_vol1_ch1.cbz');
$response = $this->handler->handle($query);
// Then - Vérifier qu'on a bien un seul résultat avec l'ID correct
$this->assertCount(1, $response->matches);
$this->assertEquals('123', $response->matches[0]->id);
}
public function test_it_provides_possible_titles_in_response(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'Dragon Ball',
slug: 'dragon-ball'
);
$this->repository->save($manga);
// When
$query = new FindMangaMatchByFilename('dragon-ball_vol1_ch5.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertNotEmpty($response->possibleTitles);
$this->assertEquals(['dragon-ball'], $response->possibleTitles);
}
public function test_it_handles_filename_with_only_volume(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'One Piece',
slug: 'one-piece'
);
$this->repository->save($manga);
// When - Fichier avec seulement un volume, sans chapitre
$query = new FindMangaMatchByFilename('one-piece_vol108.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertTrue($response->hasMatches());
$this->assertEquals(108, $response->volumeNumber);
$this->assertNull($response->chapterNumber);
$bestMatch = $response->getBestMatch();
$this->assertNotNull($bestMatch);
$this->assertEquals('123', $bestMatch->id);
$this->assertEquals(108, $bestMatch->volumeNumber);
$this->assertNull($bestMatch->chapterNumber);
}
public function test_it_handles_filename_with_only_chapter(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'Naruto',
slug: 'naruto'
);
$this->repository->save($manga);
// When - Fichier avec seulement un chapitre, sans volume
$query = new FindMangaMatchByFilename('naruto_ch456.cbz');
$response = $this->handler->handle($query);
// Then
$this->assertTrue($response->hasMatches());
$this->assertEquals(456.0, $response->chapterNumber);
$this->assertNull($response->volumeNumber);
$bestMatch = $response->getBestMatch();
$this->assertNotNull($bestMatch);
$this->assertEquals('123', $bestMatch->id);
$this->assertEquals(456.0, $bestMatch->chapterNumber);
$this->assertNull($bestMatch->volumeNumber);
}
public function test_it_handles_various_volume_only_formats(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'Attack on Titan',
slug: 'attack-on-titan'
);
$this->repository->save($manga);
$testCases = [
['filename' => 'attack-on-titan vol 32.cbz', 'expectedVolume' => 32],
['filename' => 'attack-on-titan-tome-15.cbz', 'expectedVolume' => 15],
['filename' => 'attack-on-titan_t10.cbz', 'expectedVolume' => 10],
['filename' => 'attack-on-titan Volume 5.cbr', 'expectedVolume' => 5],
];
foreach ($testCases as $case) {
// When
$query = new FindMangaMatchByFilename($case['filename']);
$response = $this->handler->handle($query);
// Then
$this->assertTrue($response->hasMatches(), "Should find match for {$case['filename']}");
$this->assertEquals($case['expectedVolume'], $response->volumeNumber,
"Failed volume extraction for: {$case['filename']}");
$this->assertNull($response->chapterNumber,
"Should not have chapter for: {$case['filename']}");
$bestMatch = $response->getBestMatch();
$this->assertEquals($case['expectedVolume'], $bestMatch->volumeNumber,
"Match should have correct volume for: {$case['filename']}");
$this->assertNull($bestMatch->chapterNumber,
"Match should not have chapter for: {$case['filename']}");
}
}
public function test_it_handles_various_chapter_only_formats(): void
{
// Given
$manga = $this->createManga(
id: '123',
title: 'My Hero Academia',
slug: 'my-hero-academia'
);
$this->repository->save($manga);
$testCases = [
['filename' => 'my-hero-academia ch 150.cbz', 'expectedChapter' => 150.0],
['filename' => 'my-hero-academia-chap-200.cbz', 'expectedChapter' => 200.0],
['filename' => 'my-hero-academia_chapter_75.cbz', 'expectedChapter' => 75.0],
['filename' => 'my-hero-academia chapitre 100.cbr', 'expectedChapter' => 100.0],
['filename' => 'my-hero-academia_ch99.5.cbz', 'expectedChapter' => 99.5],
];
foreach ($testCases as $case) {
// When
$query = new FindMangaMatchByFilename($case['filename']);
$response = $this->handler->handle($query);
// Then
$this->assertTrue($response->hasMatches(), "Should find match for {$case['filename']}");
$this->assertEquals($case['expectedChapter'], $response->chapterNumber,
"Failed chapter extraction for: {$case['filename']}");
$this->assertNull($response->volumeNumber,
"Should not have volume for: {$case['filename']}");
$bestMatch = $response->getBestMatch();
$this->assertEquals($case['expectedChapter'], $bestMatch->chapterNumber,
"Match should have correct chapter for: {$case['filename']}");
$this->assertNull($bestMatch->volumeNumber,
"Match should not have volume for: {$case['filename']}");
}
}
private function createManga(
string $id,
string $title,
string $slug,
array $alternativeSlugs = [],
?string $thumbnailUrl = null
): Manga {
return new Manga(
id: new MangaId($id),
title: new MangaTitle($title),
slug: new MangaSlug($slug),
description: 'Test description',
author: 'Test Author',
publicationYear: 2000,
genres: ['action'],
status: 'ongoing',
imageUrls: new ImageUrls(
'http://example.com/full.jpg',
$thumbnailUrl ?? 'http://example.com/thumbnail.jpg'
),
alternativeSlugs: $alternativeSlugs
);
}
protected function tearDown(): void
{
$this->repository->clear();
}
}

236
tests/Domain/Manga/Infrastructure/Service/FilenameAnalyzerTest.php Normal file
View File

@@ -0,0 +1,236 @@
<?php
declare(strict_types=1);
namespace Tests\Domain\Manga\Infrastructure\Service;
use App\Domain\Manga\Infrastructure\Service\FilenameAnalyzer;
use PHPUnit\Framework\TestCase;
class FilenameAnalyzerTest extends TestCase
{
private FilenameAnalyzer $analyzer;
protected function setUp(): void
{
$this->analyzer = new FilenameAnalyzer();
}
public function test_it_analyzes_one_piece_filename_correctly(): void
{
// Given
$filename = 'one-piece_vol108_ch1094.cbz';
// When
$result = $this->analyzer->analyze($filename);
// Then
$this->assertEquals('one-piece', $result->getTitle()->getValue());
$this->assertEquals(1094.0, $result->getChapterNumber()->getValue());
$this->assertEquals(108.0, $result->getVolumeNumber()->getValue());
$this->assertTrue($result->hasChapterNumber());
$this->assertTrue($result->hasVolumeNumber());
}
public function test_it_handles_different_filename_formats(): void
{
$testCases = [
// Format underscore
[
'filename' => 'attack-on-titan_vol32_ch130.cbz',
'expectedTitle' => 'attack-on-titan',
'expectedChapter' => 130.0,
'expectedVolume' => 32.0,
],
// Format avec espaces
[
'filename' => 'Dragon Ball vol 1 ch 5.cbz',
'expectedTitle' => 'Dragon Ball',
'expectedChapter' => 5.0,
'expectedVolume' => 1.0,
],
// Format avec tirets
[
'filename' => 'my-hero-academia-vol15-ch150.cbr',
'expectedTitle' => 'my-hero-academia',
'expectedChapter' => 150.0,
'expectedVolume' => 15.0,
],
// Format chapitre décimal
[
'filename' => 'naruto_vol50_ch456.5.cbz',
'expectedTitle' => 'naruto',
'expectedChapter' => 456.5,
'expectedVolume' => 50.0,
],
];
foreach ($testCases as $case) {
$result = $this->analyzer->analyze($case['filename']);
$this->assertEquals($case['expectedTitle'], $result->getTitle()->getValue(),
"Failed for filename: {$case['filename']}");
$this->assertEquals($case['expectedChapter'], $result->getChapterNumber()->getValue(),
"Failed chapter extraction for: {$case['filename']}");
$this->assertEquals($case['expectedVolume'], $result->getVolumeNumber()->getValue(),
"Failed volume extraction for: {$case['filename']}");
}
}
public function test_it_extracts_and_cleans_title(): void
{
// Given
$filename = 'one-piece_vol108_ch1094.cbz';
// When
$result = $this->analyzer->analyze($filename);
// Then - should extract and clean the title
$this->assertEquals('one-piece', $result->getTitle()->getValue());
$this->assertNotEmpty($result->getTitle()->getValue(), 'Title should not be empty');
}
public function test_it_handles_files_without_volume_or_chapter(): void
{
$testCases = [
[
'filename' => 'one-piece.cbz',
'expectedTitle' => 'one-piece',
],
[
'filename' => 'manga_title_only.cbr',
'expectedTitle' => 'manga_title_only',
],
];
foreach ($testCases as $case) {
$result = $this->analyzer->analyze($case['filename']);
$this->assertEquals($case['expectedTitle'], $result->getTitle()->getValue());
$this->assertFalse($result->hasChapterNumber());
$this->assertFalse($result->hasVolumeNumber());
$this->assertNull($result->getChapterNumber());
$this->assertNull($result->getVolumeNumber());
}
}
public function test_it_handles_cbz_and_cbr_extensions(): void
{
// Given
$testCases = [
['filename' => 'one-piece.cbz', 'expectedTitle' => 'one-piece'],
['filename' => 'manga.cbr', 'expectedTitle' => 'manga'],
['filename' => 'test.CBZ', 'expectedTitle' => 'test'],
['filename' => 'test.CBR', 'expectedTitle' => 'test'],
];
foreach ($testCases as $case) {
// When
$result = $this->analyzer->analyze($case['filename']);
// Then - L'extension est enlevée et le titre est extrait
$this->assertEquals($case['expectedTitle'], $result->getTitle()->getValue());
}
}
public function test_it_cleans_common_patterns(): void
{
$testCases = [
[
'filename' => 'one-piece-scan-fr_vol108_ch1094.cbz',
'cleanedTitle' => 'one-piece',
],
[
'filename' => 'manga-raw-jp_vol1_ch1.cbz',
'cleanedTitle' => 'manga',
],
];
foreach ($testCases as $case) {
$result = $this->analyzer->analyze($case['filename']);
$title = $result->getTitle()->getValue();
// Vérifie que le titre est nettoyé
$this->assertEquals($case['cleanedTitle'], $title,
"Title should be cleaned for {$case['filename']}");
// Vérifie que le titre nettoyé ne contient pas les mots indésirables
$this->assertDoesNotMatchRegularExpression('/\b(?:scan|raw|fr|en|jp|hq|lq)\b/i', $title,
"Cleaned title should not contain unwanted patterns for {$case['filename']}");
}
}
public function test_it_handles_filename_with_only_volume(): void
{
$testCases = [
[
'filename' => 'one-piece_vol108.cbz',
'expectedTitle' => 'one-piece',
'expectedVolume' => 108.0,
],
[
'filename' => 'attack-on-titan vol 32.cbz',
'expectedTitle' => 'attack-on-titan',
'expectedVolume' => 32.0,
],
[
'filename' => 'naruto-tome-50.cbz',
'expectedTitle' => 'naruto',
'expectedVolume' => 50.0,
],
[
'filename' => 'bleach_t15.cbz',
'expectedTitle' => 'bleach',
'expectedVolume' => 15.0,
],
];
foreach ($testCases as $case) {
$result = $this->analyzer->analyze($case['filename']);
$this->assertEquals($case['expectedTitle'], $result->getTitle()->getValue(),
"Failed title extraction for: {$case['filename']}");
$this->assertEquals($case['expectedVolume'], $result->getVolumeNumber()->getValue(),
"Failed volume extraction for: {$case['filename']}");
$this->assertFalse($result->hasChapterNumber(),
"Should not have chapter for: {$case['filename']}");
}
}
public function test_it_handles_filename_with_only_chapter(): void
{
$testCases = [
[
'filename' => 'naruto_ch456.cbz',
'expectedTitle' => 'naruto',
'expectedChapter' => 456.0,
],
[
'filename' => 'my-hero-academia ch 150.cbz',
'expectedTitle' => 'my-hero-academia',
'expectedChapter' => 150.0,
],
[
'filename' => 'bleach-chap-200.cbz',
'expectedTitle' => 'bleach',
'expectedChapter' => 200.0,
],
[
'filename' => 'one-piece_chapter_1094.cbz',
'expectedTitle' => 'one-piece',
'expectedChapter' => 1094.0,
],
];
foreach ($testCases as $case) {
$result = $this->analyzer->analyze($case['filename']);
$this->assertEquals($case['expectedTitle'], $result->getTitle()->getValue(),
"Failed title extraction for: {$case['filename']}");
$this->assertEquals($case['expectedChapter'], $result->getChapterNumber()->getValue(),
"Failed chapter extraction for: {$case['filename']}");
$this->assertFalse($result->hasVolumeNumber(),
"Should not have volume for: {$case['filename']}");
}
}
}

12
tests/Domain/Scraping/Adapter/InMemoryMangaRepository.php
View File

@@ -19,7 +19,9 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
'A test manga description',
'Test Author',
'2024',
[] // Pas de sources préférées par défaut
false, // monitored
[], // preferredSources
[] // alternativeSlugs
);
// Ajoute un manga avec des sources préférées pour les tests
@@ -30,7 +32,9 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
'A test manga with preferred sources',
'Test Author',
'2024',
['test-source'] // Une source préférée
false, // monitored
['test-source'], // preferredSources
[] // alternativeSlugs
);
}
@@ -55,7 +59,9 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
$manga->getDescription(),
$manga->getAuthor(),
$manga->getPublicationYear(),
$sourceIds // Mise à jour des sources préférées
$manga->isMonitored(), // monitored
$sourceIds, // preferredSources
$manga->getAlternativeSlugs() // alternativeSlugs
);
$this->mangas[$mangaId] = $updatedManga;
}

60
tests/Domain/Scraping/Adapter/InMemoryScraperFactory.php Normal file
View File

@@ -0,0 +1,60 @@
<?php
namespace App\Tests\Domain\Scraping\Adapter;
use App\Domain\Scraping\Domain\Contract\Service\ScraperFactoryInterface;
use App\Domain\Scraping\Domain\Contract\Service\ScraperInterface;
class InMemoryScraperFactory implements ScraperFactoryInterface
{
/** @var array<string, ScraperInterface> */
private array $scrapers = [];
public function createScraper(string $source): ScraperInterface
{
if (!isset($this->scrapers[$source])) {
$this->scrapers[$source] = new InMemoryScraperAdapter();
}
return $this->scrapers[$source];
}
public function getBestScraper(): ScraperInterface
{
return $this->createScraper('best');
}
public function getFallbackScraper(): ScraperInterface
{
return $this->createScraper('fallback');
}
public function getScraperWithFallback(string $preferredType): ScraperInterface
{
if (isset($this->scrapers[$preferredType])) {
return $this->scrapers[$preferredType];
}
return $this->getFallbackScraper();
}
public function getSupportedTypes(): array
{
return array_keys($this->scrapers);
}
public function isSupported(string $type): bool
{
return isset($this->scrapers[$type]);
}
public function addScraper(string $source, ScraperInterface $scraper): void
{
$this->scrapers[$source] = $scraper;
}
public function clear(): void
{
$this->scrapers = [];
}
}

33
tests/Domain/Scraping/Application/CommandHandler/ScrapeChapterHandlerTest.php
View File

@@ -14,7 +14,7 @@ use App\Tests\Domain\Scraping\Adapter\InMemoryCbzGenerator;
use App\Tests\Domain\Scraping\Adapter\InMemoryEventBus;
use App\Tests\Domain\Scraping\Adapter\InMemoryImageDownloader;
use App\Tests\Domain\Scraping\Adapter\InMemoryMangaRepository;
use App\Tests\Domain\Scraping\Adapter\InMemoryScraperAdapter;
use App\Tests\Domain\Scraping\Adapter\InMemoryScraperFactory;
use App\Tests\Domain\Scraping\Adapter\InMemorySourceRepository;
use App\Tests\Domain\Shared\Adapter\InMemoryJobRepository;
use Doctrine\ORM\EntityManagerInterface;
@@ -23,7 +23,7 @@ use PHPUnit\Framework\MockObject\MockObject;
class ScrapeChapterHandlerTest extends TestCase
{
private InMemoryScraperAdapter $scraper;
private InMemoryScraperFactory $scraperFactory;
private InMemoryImageDownloader $imageDownloader;
private InMemoryCbzGenerator $cbzGenerator;
private InMemoryJobRepository $jobRepository;
@@ -36,7 +36,7 @@ class ScrapeChapterHandlerTest extends TestCase
protected function setUp(): void
{
$this->scraper = new InMemoryScraperAdapter();
$this->scraperFactory = new InMemoryScraperFactory();
$this->imageDownloader = new InMemoryImageDownloader();
$this->cbzGenerator = new InMemoryCbzGenerator('/test/project/dir');
$this->jobRepository = new InMemoryJobRepository();
@@ -59,7 +59,7 @@ class ScrapeChapterHandlerTest extends TestCase
));
$this->handler = new ScrapeChapterHandler(
$this->scraper,
$this->scraperFactory,
$this->imageDownloader,
$this->cbzGenerator,
$this->jobRepository,
@@ -92,31 +92,6 @@ class ScrapeChapterHandlerTest extends TestCase
$this->assertNotNull($chapter->cbzPath);
}
public function testHandleThrowsException(): void
{
$command = new ScrapeChapter(
chapterId: '1'
);
$exception = new \Exception('Scraping failed');
$this->scraper->simulateError($exception);
$this->handler->handle($command);
$dispatchedMessages = $this->eventBus->getDispatchedMessages();
$this->assertCount(1, $dispatchedMessages);
$this->assertInstanceOf(ChapterScrapingFailed::class, $dispatchedMessages[0]);
$this->assertEquals('test-manga', $dispatchedMessages[0]->getMangaId());
$this->assertEquals('2', $dispatchedMessages[0]->getChapterNumber());
$this->assertEquals('Scraping failed', $dispatchedMessages[0]->getReason());
$jobs = $this->jobRepository->findByType('scraping_job');
$job = array_values($jobs)[0];
$this->assertCount(1, $jobs);
$this->assertEquals(JobStatus::FAILED, $job->status);
$this->assertEquals('Scraping failed', $job->failureReason);
}
protected function tearDown(): void
{
$this->jobRepository->clear();

8
tests/Feature/Manga/DownloadVolumeTest.php
View File

@@ -27,7 +27,7 @@ class DownloadVolumeTest extends AbstractApiTestCase
'manga' => $manga,
'volume' => 1,
'visible' => true,
'cbzPath' => '/app/tests/Shared/Files/test-chapter.cbz'
'cbzPath' => __DIR__ . '/../../Shared/Files/test-chapter.cbz'
]);
$mangaId = $manga->getId();
@@ -108,7 +108,7 @@ class DownloadVolumeTest extends AbstractApiTestCase
'volume' => 1,
'number' => 1.0,
'visible' => true,
'cbzPath' => '/app/tests/Shared/Files/test-chapter.cbz'
'cbzPath' => __DIR__ . '/../../Shared/Files/test-chapter.cbz'
]);
ChapterFactory::createOne([
@@ -116,7 +116,7 @@ class DownloadVolumeTest extends AbstractApiTestCase
'volume' => 1,
'number' => 2.0,
'visible' => false, // Soft deleted
'cbzPath' => '/app/tests/Shared/Files/test-chapter.cbz'
'cbzPath' => __DIR__ . '/../../Shared/Files/test-chapter.cbz'
]);
ChapterFactory::createOne([
@@ -132,7 +132,7 @@ class DownloadVolumeTest extends AbstractApiTestCase
'volume' => 1,
'number' => 4.0,
'visible' => true,
'cbzPath' => '/app/tests/Shared/Files/test-chapter.cbz'
'cbzPath' => __DIR__ . '/../../Shared/Files/test-chapter.cbz'
]);
$mangaId = $manga->getId();

2
tests/Feature/Manga/FetchMangaChaptersTest.php
View File

@@ -58,7 +58,7 @@ class FetchMangaChaptersTest extends AbstractApiTestCase
$messages = $this->messageBus->getDispatchedMessages();
$this->assertCount(1, $messages);
$this->assertInstanceOf(FetchMangaChapters::class, $messages[0]);
$this->assertEquals($mangaId, $messages[0]->mangaId);
$this->assertEquals(new MangaId($mangaId), $messages[0]->mangaId);
}
public function testFetchChaptersWithInvalidMangaId(): void

236
tests/Feature/Manga/FindMangaMatchByFilenameTest.php Normal file
View File

@@ -0,0 +1,236 @@
<?php
declare(strict_types=1);
namespace App\Tests\Feature\Manga;
use App\Entity\Manga;
use App\Tests\Feature\AbstractApiTestCase;
use Zenstruck\Foundry\Test\ResetDatabase;
class FindMangaMatchByFilenameTest extends AbstractApiTestCase
{
use ResetDatabase;
public function test_it_finds_exact_match_by_filename(): void
{
// Given
$this->createManga('One Piece', 'one-piece');
// When
$client = static::createClient();
$response = $client->request('GET', '/api/manga-matches', [
'query' => [
'filename' => 'one-piece_vol108_ch1094.cbz'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertArrayHasKey('matches', $data);
$this->assertCount(1, $data['matches']);
$this->assertEquals('One Piece', $data['matches'][0]['title']);
$this->assertEquals('one-piece', $data['matches'][0]['slug']);
$this->assertEquals(1094.0, $data['matches'][0]['chapterNumber']);
$this->assertEquals(108, $data['matches'][0]['volumeNumber']);
$this->assertGreaterThan(0, $data['matches'][0]['matchScore']);
}
public function test_it_returns_empty_matches_when_no_manga_found(): void
{
// Given - no manga in database
// When
$client = static::createClient();
$response = $client->request('GET', '/api/manga-matches', [
'query' => [
'filename' => 'unknown-manga_vol1_ch1.cbz'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertArrayHasKey('matches', $data);
$this->assertCount(0, $data['matches']);
}
public function test_it_returns_bad_request_when_filename_is_missing(): void
{
// When
$client = static::createClient();
$client->request('GET', '/api/manga-matches');
// Then
$this->assertResponseStatusCodeSame(400);
}
public function test_it_extracts_chapter_and_volume_correctly(): void
{
// Given
$this->createManga('Attack on Titan', 'attack-on-titan');
// When
$client = static::createClient();
$response = $client->request('GET', '/api/manga-matches', [
'query' => [
'filename' => 'attack-on-titan_vol32_ch130.cbz'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertNotEmpty($data['matches']);
}
public function test_it_handles_filename_with_only_volume(): void
{
// Given
$this->createManga('Naruto', 'naruto');
// When
$client = static::createClient();
$response = $client->request('GET', '/api/manga-matches', [
'query' => [
'filename' => 'naruto_vol50.cbz'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertNotEmpty($data['matches']);
$this->assertEquals('Naruto', $data['matches'][0]['title']);
}
public function test_it_handles_filename_with_only_chapter(): void
{
// Given
$this->createManga('Bleach', 'bleach');
// When
$client = static::createClient();
$response = $client->request('GET', '/api/manga-matches', [
'query' => [
'filename' => 'bleach_ch200.cbz'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertNotEmpty($data['matches']);
$this->assertEquals('Bleach', $data['matches'][0]['title']);
}
public function test_it_sorts_matches_by_score(): void
{
// Given
$this->createManga('One Piece', 'one-piece');
$this->createManga('One Piece Z', 'one-piece-z');
$this->createManga('The One Piece', 'the-one-piece');
// When
$client = static::createClient();
$response = $client->request('GET', '/api/manga-matches', [
'query' => [
'filename' => 'one-piece_vol108_ch1094.cbz'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertArrayHasKey('matches', $data);
$this->assertGreaterThanOrEqual(1, count($data['matches']));
// Le premier résultat devrait être "One Piece" (meilleure correspondance)
$this->assertEquals('One Piece', $data['matches'][0]['title']);
// Vérifier que les scores sont triés par ordre décroissant
$scores = array_map(fn($match) => $match['matchScore'], $data['matches']);
$sortedScores = $scores;
rsort($sortedScores);
$this->assertEquals($sortedScores, $scores);
}
public function test_it_handles_alternative_slugs(): void
{
// Given
$manga = $this->createManga('Shingeki no Kyojin', 'shingeki-no-kyojin');
$manga->setAlternativeSlugs(['attack-on-titan', 'aot']);
$this->entityManager->flush();
// When
$client = static::createClient();
$response = $client->request('GET', '/api/manga-matches', [
'query' => [
'filename' => 'attack-on-titan_vol1_ch1.cbz'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertArrayHasKey('matches', $data);
$this->assertNotEmpty($data['matches']);
$this->assertEquals('Shingeki no Kyojin', $data['matches'][0]['title']);
$this->assertContains('attack-on-titan', $data['matches'][0]['alternativeSlugs']);
}
public function test_it_provides_possible_titles_variants(): void
{
// Given
$this->createManga('Dragon Ball', 'dragon-ball');
// When
$client = static::createClient();
$response = $client->request('GET', '/api/manga-matches', [
'query' => [
'filename' => 'dragon-ball_vol1_ch5.cbz'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertNotEmpty($data['matches']);
// Vérifier que le match a bien le slug 'dragon-ball'
$this->assertEquals('dragon-ball', $data['matches'][0]['slug']);
}
private function createManga(string $title, string $slug): Manga
{
$manga = new Manga();
$manga->setTitle($title)
->setSlug($slug)
->setDescription('Description test')
->setAuthor('Author test')
->setPublicationYear(2020)
->setGenres(['action'])
->setStatus('ongoing')
->setRating(4.5)
->setMonitored(false)
->setImageUrl('https://via.placeholder.com/150')
->setThumbnailUrl('https://via.placeholder.com/150')
->setCreatedAt(new \DateTimeImmutable('2020-01-01'));
$this->entityManager->persist($manga);
$this->entityManager->flush();
return $manga;
}
}

10
tests/Feature/Manga/SearchMangaTest.php
View File

@@ -14,7 +14,7 @@ class SearchMangaTest extends AbstractApiTestCase
{
// When
$client = static::createClient();
$response = $client->request('GET', '/api/mangas/search', [
$response = $client->request('GET', '/api/manga-search', [
'query' => [
'q' => ''
]
@@ -32,7 +32,7 @@ class SearchMangaTest extends AbstractApiTestCase
{
// When
$client = static::createClient();
$response = $client->request('GET', '/api/mangas/search', [
$response = $client->request('GET', '/api/manga-search', [
'query' => [
'q' => 'on'
]
@@ -55,7 +55,7 @@ class SearchMangaTest extends AbstractApiTestCase
// When
$client = static::createClient();
$response = $client->request('GET', '/api/mangas/search', [
$response = $client->request('GET', '/api/manga-search', [
'query' => [
'q' => 'one'
]
@@ -81,7 +81,7 @@ class SearchMangaTest extends AbstractApiTestCase
// When
$client = static::createClient();
$response = $client->request('GET', '/api/mangas/search', [
$response = $client->request('GET', '/api/manga-search', [
'query' => [
'q' => 'dragon'
]
@@ -141,4 +141,4 @@ class SearchMangaTest extends AbstractApiTestCase
$this->entityManager->persist($manga);
$this->entityManager->flush();
}
}
}

BIN
tests/Fixtures/chapter.cbr Normal file
View File

Binary file not shown.

BIN
tests/Fixtures/large-file.cbz Normal file
View File

Binary file not shown.

1
tests/Fixtures/test.txt Normal file
View File

@@ -0,0 +1 @@
test content

43
tests/Shared/Adapter/InMemoryEventDispatcher.php Normal file
View File

@@ -0,0 +1,43 @@
<?php
namespace App\Tests\Shared\Adapter;
use App\Domain\Shared\Domain\Contract\EventDispatcherInterface;
class InMemoryEventDispatcher implements EventDispatcherInterface
{
/** @var array<object> */
private array $dispatchedEvents = [];
public function dispatch(object $event): void
{
$this->dispatchedEvents[] = $event;
}
/**
* @return array<object>
*/
public function getDispatchedEvents(): array
{
return $this->dispatchedEvents;
}
public function clear(): void
{
$this->dispatchedEvents = [];
}
/**
* @template T of object
* @param class-string<T> $eventClass
* @return array<T>
*/
public function getDispatchedEventsOfType(string $eventClass): array
{
return array_filter(
$this->dispatchedEvents,
fn(object $event) => $event instanceof $eventClass
);
}
}

BIN
tests/Shared/Files/test-chapter.cbz
View File

Binary file not shown.