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

feat: GetChapters endpoint + tests

Browse Source
This commit is contained in:
ext.jeremy.guillot@maxicoffee.domains
2025-02-10 20:07:24 +01:00
parent 2f615a4936
commit 6667cc224b
15 changed files with 601 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/Domain/Manga/Application/Query/GetMangaChapters.php Normal file
View File

@@ -0,0 +1,13 @@
<?php
namespace App\Domain\Manga\Application\Query;
readonly class GetMangaChapters
{
public function __construct(
public string $mangaId,
public ?int $page = 1,
public ?int $limit = 20,
public ?string $sortOrder = 'desc'
) {}
}

50
src/Domain/Manga/Application/QueryHandler/GetMangaChaptersHandler.php Normal file
View File

@@ -0,0 +1,50 @@
<?php
namespace App\Domain\Manga\Application\QueryHandler;
use App\Domain\Manga\Application\Query\GetMangaChapters;
use App\Domain\Manga\Application\Response\ChapterListResponse;
use App\Domain\Manga\Application\Response\ChapterResponse;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Exception\MangaNotFoundException;
readonly class GetMangaChaptersHandler
{
public function __construct(
private MangaRepositoryInterface $mangaRepository
) {}
public function handle(GetMangaChapters $query): ChapterListResponse
{
$manga = $this->mangaRepository->findById($query->mangaId);
if (!$manga) {
throw new MangaNotFoundException();
}
$chapters = $this->mangaRepository->findChapters(
mangaId: $query->mangaId,
page: $query->page,
limit: $query->limit,
sortOrder: $query->sortOrder
);
$total = $this->mangaRepository->countChapters($query->mangaId);
return new ChapterListResponse(
chapters: array_map(
fn ($chapter) => new ChapterResponse(
id: $chapter->getId(),
number: $chapter->getNumber(),
title: $chapter->getTitle(),
volume: $chapter->getVolume(),
isVisible: $chapter->isVisible(),
createdAt: $chapter->getCreatedAt()
),
$chapters
),
total: $total,
page: $query->page,
limit: $query->limit
);
}
}

28
src/Domain/Manga/Application/Response/ChapterListResponse.php Normal file
View File

@@ -0,0 +1,28 @@
<?php
namespace App\Domain\Manga\Application\Response;
readonly class ChapterListResponse
{
public function __construct(
public array $chapters,
public int $total,
public int $page,
public int $limit
) {}
public function getTotalPages(): int
{
return (int) ceil($this->total / $this->limit);
}
public function hasNextPage(): bool
{
return $this->page < $this->getTotalPages();
}
public function hasPreviousPage(): bool
{
return $this->page > 1;
}
}

15
src/Domain/Manga/Application/Response/ChapterResponse.php Normal file
View File

@@ -0,0 +1,15 @@
<?php
namespace App\Domain\Manga\Application\Response;
readonly class ChapterResponse
{
public function __construct(
public string $id,
public float $number,
public ?string $title,
public ?int $volume,
public bool $isVisible,
public \DateTimeImmutable $createdAt
) {}
}

2
src/Domain/Manga/Domain/Contract/Repository/MangaRepositoryInterface.php
View File

@@ -11,4 +11,6 @@ interface MangaRepositoryInterface
public function findById(string $id): ?Manga;
public function save(Manga $manga): void;
public function delete(Manga $manga): void;
public function findChapters(string $mangaId, int $page = 1, int $limit = 20, string $sortOrder = 'desc'): array;
public function countChapters(string $mangaId): int;
}

48
src/Domain/Manga/Domain/Model/Chapter.php Normal file
View File

@@ -0,0 +1,48 @@
<?php
namespace App\Domain\Manga\Domain\Model;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
readonly class Chapter
{
public function __construct(
private ChapterId $id,
private string $mangaId,
private float $number,
private ?string $title,
private ?int $volume,
private bool $isVisible,
private \DateTimeImmutable $createdAt
) {}
public function getId(): string
{
return $this->id->getValue();
}
public function getNumber(): float
{
return $this->number;
}
public function getTitle(): ?string
{
return $this->title;
}
public function getVolume(): ?int
{
return $this->volume;
}
public function isVisible(): bool
{
return $this->isVisible;
}
public function getCreatedAt(): \DateTimeImmutable
{
return $this->createdAt;
}
}

20
src/Domain/Manga/Domain/Model/ValueObject/ChapterId.php Normal file
View File

@@ -0,0 +1,20 @@
<?php
namespace App\Domain\Manga\Domain\Model\ValueObject;
readonly class ChapterId
{
public function __construct(
private string $value
) {}
public function getValue(): string
{
return $this->value;
}
public function equals(self $other): bool
{
return $this->value === $other->value;
}
}

16
src/Domain/Manga/Infrastructure/ApiPlatform/Dto/ChapterCollection.php Normal file
View File

@@ -0,0 +1,16 @@
<?php
namespace App\Domain\Manga\Infrastructure\ApiPlatform\Dto;
readonly class ChapterCollection
{
public function __construct(
/** @var ChapterListItem[] */
public array $items,
public int $total,
public int $page,
public int $limit,
public bool $hasNextPage,
public bool $hasPreviousPage
) {}
}

18
src/Domain/Manga/Infrastructure/ApiPlatform/Dto/ChapterListItem.php Normal file
View File

@@ -0,0 +1,18 @@
<?php
namespace App\Domain\Manga\Infrastructure\ApiPlatform\Dto;
use ApiPlatform\Metadata\ApiProperty;
readonly class ChapterListItem
{
public function __construct(
#[ApiProperty(identifier: true)]
public string $id,
public float $number,
public ?string $title,
public ?int $volume,
public bool $isVisible,
public string $createdAt
) {}
}

22
src/Domain/Manga/Infrastructure/ApiPlatform/Resource/MangaChaptersResource.php Normal file
View File

@@ -0,0 +1,22 @@
<?php
namespace App\Domain\Manga\Infrastructure\ApiPlatform\Resource;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use App\Domain\Manga\Infrastructure\ApiPlatform\Dto\ChapterCollection;
use App\Domain\Manga\Infrastructure\ApiPlatform\State\Provider\GetMangaChaptersStateProvider;
#[ApiResource(
shortName: 'MangaChapters',
operations: [
new Get(
uriTemplate: '/mangas/{id}/chapters',
provider: GetMangaChaptersStateProvider::class,
output: ChapterCollection::class
)
]
)]
class MangaChaptersResource
{
}

58
src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/GetMangaChaptersStateProvider.php Normal file
View File

@@ -0,0 +1,58 @@
<?php
namespace App\Domain\Manga\Infrastructure\ApiPlatform\State\Provider;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use App\Domain\Manga\Application\Query\GetMangaChapters;
use App\Domain\Manga\Application\QueryHandler\GetMangaChaptersHandler;
use App\Domain\Manga\Application\Response\ChapterResponse;
use App\Domain\Manga\Infrastructure\ApiPlatform\Dto\ChapterCollection;
use App\Domain\Manga\Infrastructure\ApiPlatform\Dto\ChapterListItem;
readonly class GetMangaChaptersStateProvider implements ProviderInterface
{
public function __construct(
private GetMangaChaptersHandler $handler
) {}
public function provide(Operation $operation, array $uriVariables = [], array $context = []): ChapterCollection
{
$page = $context['filters']['page'] ?? 1;
$limit = $context['filters']['limit'] ?? 20;
$sortOrder = $context['filters']['sortOrder'] ?? 'desc';
$query = new GetMangaChapters(
mangaId: $uriVariables['id'],
page: $page,
limit: $limit,
sortOrder: $sortOrder
);
$response = $this->handler->handle($query);
return new ChapterCollection(
items: array_map(
fn (ChapterResponse $chapter) => $this->createChapterListItem($chapter),
$response->chapters
),
total: $response->total,
page: $response->page,
limit: $response->limit,
hasNextPage: $response->hasNextPage(),
hasPreviousPage: $response->hasPreviousPage()
);
}
private function createChapterListItem(ChapterResponse $chapter): ChapterListItem
{
return new ChapterListItem(
id: $chapter->id,
number: $chapter->number,
title: $chapter->title,
volume: $chapter->volume,
isVisible: $chapter->isVisible,
createdAt: $chapter->createdAt->format(\DateTimeInterface::RFC3339)
);
}
}

46
src/Domain/Manga/Infrastructure/Persistence/LegacyMangaRepository.php
View File

@@ -10,6 +10,9 @@ use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
use App\Entity\Manga as EntityManga;
use Doctrine\ORM\EntityManagerInterface;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
use App\Entity\Chapter as EntityChapter;
readonly class LegacyMangaRepository implements MangaRepositoryInterface
{
@@ -71,6 +74,36 @@ readonly class LegacyMangaRepository implements MangaRepositoryInterface
}
}
public function findChapters(string $mangaId, int $page = 1, int $limit = 20, string $sortOrder = 'desc'): array
{
$offset = ($page - 1) * $limit;
$queryBuilder = $this->entityManager->createQueryBuilder()
->select('c')
->from(EntityChapter::class, 'c')
->where('c.manga = :mangaId')
->orderBy('c.number', $sortOrder)
->setParameter('mangaId', $mangaId)
->setFirstResult($offset)
->setMaxResults($limit);
return array_map(
fn (EntityChapter $entity) => $this->toChapterDomain($entity),
$queryBuilder->getQuery()->getResult()
);
}
public function countChapters(string $mangaId): int
{
return $this->entityManager->createQueryBuilder()
->select('COUNT(c.id)')
->from(EntityChapter::class, 'c')
->where('c.manga = :mangaId')
->setParameter('mangaId', $mangaId)
->getQuery()
->getSingleScalarResult();
}
private function toDomain(EntityManga $entity): DomainManga
{
return new DomainManga(
@@ -110,4 +143,17 @@ readonly class LegacyMangaRepository implements MangaRepositoryInterface
$entity->setRating($manga->getRating());
}
}
private function toChapterDomain(EntityChapter $entity): Chapter
{
return new Chapter(
id: new ChapterId((string)$entity->getId()),
mangaId: $entity->getManga()->getId(),
number: $entity->getNumber(),
title: $entity->getTitle(),
volume: $entity->getVolume(),
isVisible: $entity->isVisible(),
createdAt: new \DateTimeImmutable()
);
}
}

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

@@ -3,12 +3,17 @@
namespace App\Tests\Domain\Manga\Adapter;
use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
use App\Domain\Manga\Domain\Model\Chapter;
use App\Domain\Manga\Domain\Model\Manga;
use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
class InMemoryMangaRepository implements MangaRepositoryInterface
{
/** @var Manga[] */
private array $mangas = [];
/** @var array<string, Chapter[]> */
private array $chapters = [];
public function findAll(int $page = 1, int $limit = 20, string $sortBy = 'title', string $sortOrder = 'asc'): array
{
@@ -66,8 +71,49 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
};
}
public function findChapters(string $mangaId, int $page = 1, int $limit = 20, string $sortOrder = 'desc'): array
{
if (!isset($this->chapters[$mangaId])) {
return [];
}
$chapters = $this->chapters[$mangaId];
usort($chapters, function (Chapter $a, Chapter $b) use ($sortOrder) {
return $sortOrder === 'desc'
? $b->getNumber() <=> $a->getNumber()
: $a->getNumber() <=> $b->getNumber();
});
$offset = ($page - 1) * $limit;
return array_slice($chapters, $offset, $limit);
}
public function countChapters(string $mangaId): int
{
return isset($this->chapters[$mangaId]) ? count($this->chapters[$mangaId]) : 0;
}
public function addChaptersToManga(string $mangaId, int $count): void
{
$this->chapters[$mangaId] = [];
for ($i = 1; $i <= $count; $i++) {
$this->chapters[$mangaId][] = new Chapter(
id: new ChapterId((string)$i),
mangaId: $mangaId,
number: (float)$i,
title: "Chapter $i",
volume: (int)ceil($i / 10),
isVisible: true,
createdAt: new \DateTimeImmutable()
);
}
}
public function clear(): void
{
$this->mangas = [];
$this->chapters = [];
}
}

104
tests/Domain/Manga/Application/QueryHandler/GetMangaChaptersHandlerTest.php Normal file
View File

@@ -0,0 +1,104 @@
<?php
namespace App\Tests\Domain\Manga\Application\QueryHandler;
use App\Domain\Manga\Application\Query\GetMangaChapters;
use App\Domain\Manga\Application\QueryHandler\GetMangaChaptersHandler;
use App\Domain\Manga\Domain\Exception\MangaNotFoundException;
use App\Domain\Manga\Domain\Model\Manga;
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\InMemoryMangaRepository;
use PHPUnit\Framework\TestCase;
class GetMangaChaptersHandlerTest extends TestCase
{
private InMemoryMangaRepository $repository;
private GetMangaChaptersHandler $handler;
protected function setUp(): void
{
$this->repository = new InMemoryMangaRepository();
$this->handler = new GetMangaChaptersHandler($this->repository);
}
public function testHandleThrowsExceptionWhenMangaNotFound(): void
{
$this->expectException(MangaNotFoundException::class);
$query = new GetMangaChapters('non-existent-id');
$this->handler->handle($query);
}
public function testHandleReturnsEmptyListWhenNoChapters(): void
{
// Arrange
$this->givenMangaExists('123');
// Act
$query = new GetMangaChapters('123');
$response = $this->handler->handle($query);
// Assert
$this->assertEmpty($response->chapters);
$this->assertEquals(0, $response->total);
$this->assertEquals(1, $response->page);
$this->assertEquals(20, $response->limit);
$this->assertFalse($response->hasNextPage());
$this->assertFalse($response->hasPreviousPage());
}
public function testHandleReturnsPaginatedChapters(): void
{
// Arrange
$this->givenMangaExistsWithChapters('123', 25);
// Act
$query = new GetMangaChapters('123', page: 2, limit: 10);
$response = $this->handler->handle($query);
// Assert
$this->assertCount(10, $response->chapters);
$this->assertEquals(25, $response->total);
$this->assertEquals(2, $response->page);
$this->assertEquals(10, $response->limit);
$this->assertTrue($response->hasNextPage());
$this->assertTrue($response->hasPreviousPage());
}
protected function tearDown(): void
{
$this->repository->clear();
}
private function givenMangaExists(string $id): void
{
$manga = $this->createManga($id);
$this->repository->save($manga);
}
private function givenMangaExistsWithChapters(string $id, int $chapterCount): void
{
$this->givenMangaExists($id);
// Note: We'll need to implement this in InMemoryMangaRepository
$this->repository->addChaptersToManga($id, $chapterCount);
}
private function createManga(string $id): Manga
{
return new Manga(
id: new MangaId($id),
title: new MangaTitle('Test Manga'),
slug: new MangaSlug('test-manga'),
description: 'This is a test manga',
author: 'Test Author',
publicationYear: 2024,
genres: ['Action', 'Adventure'],
status: 'Ongoing',
externalId: null,
imageUrl: null,
rating: null
);
}
}

115
tests/Feature/Manga/GetMangaChaptersTest.php Normal file
View File

@@ -0,0 +1,115 @@
<?php
namespace App\Tests\Feature\Manga;
use App\Entity\Chapter;
use App\Entity\Manga;
use App\Tests\Feature\AbstractApiTestCase;
use Zenstruck\Foundry\Test\ResetDatabase;
class GetMangaChaptersTest extends AbstractApiTestCase
{
use ResetDatabase;
public function testGetChaptersOfNonExistentManga(): void
{
// When
$client = static::createClient();
$response = $client->request('GET', '/api/mangas/999/chapters');
// Then
$this->assertResponseStatusCodeSame(404);
}
public function testGetEmptyChapterList(): void
{
// Given
$manga = $this->createManga();
// When
$client = static::createClient();
$response = $client->request('GET', '/api/mangas/' . $manga->getId() . '/chapters');
// Then
$this->assertResponseIsSuccessful();
$this->assertJsonContains([
'total' => 0,
'page' => 1,
'limit' => 20,
'hasNextPage' => false,
'hasPreviousPage' => false,
'items' => []
]);
}
public function testGetChaptersWithPagination(): void
{
// Given
$manga = $this->createManga();
$this->createChapters($manga, 25);
// When
$client = static::createClient();
$response = $client->request('GET', '/api/mangas/' . $manga->getId() . '/chapters', [
'query' => [
'page' => 2,
'limit' => 10,
'sortOrder' => 'desc'
]
]);
// Then
$this->assertResponseIsSuccessful();
$data = $response->toArray();
$this->assertCount(10, $data['items']);
$this->assertEquals(25, $data['total']);
$this->assertEquals(2, $data['page']);
$this->assertEquals(10, $data['limit']);
$this->assertTrue($data['hasNextPage']);
$this->assertTrue($data['hasPreviousPage']);
$numbers = array_map(fn($item) => $item['number'], $data['items']);
$expectedNumbers = $numbers;
rsort($expectedNumbers);
$this->assertEquals($expectedNumbers, $numbers);
}
private function createManga(): Manga
{
$manga = new Manga();
$manga->setTitle('One Piece')
->setSlug('one-piece')
->setDescription('Test description')
->setAuthor('Eiichiro Oda')
->setPublicationYear(1997)
->setGenres(['action', 'adventure'])
->setStatus('ongoing')
->setMonitored(true);
$entityManager = static::getContainer()->get('doctrine')->getManager();
$entityManager->persist($manga);
$entityManager->flush();
return $manga;
}
private function createChapters(Manga $manga, int $count): void
{
$entityManager = static::getContainer()->get('doctrine')->getManager();
for ($i = 1; $i <= $count; $i++) {
$chapter = new Chapter();
$chapter->setManga($manga)
->setNumber($i)
->setTitle("Chapter $i")
->setVolume((int)ceil($i / 10))
->setVisible(true);
$entityManager->persist($chapter);
}
$entityManager->flush();
}
}