lubiana/futtern
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases 32 Packages Wiki Activity Actions

migrate to pest php for testing #77

Merged
lubiana merged 2 commits from introduce-pest into main 2025-02-01 21:39:05 +00:00
Conversation 0 Commits 2 Files changed 24 +1989 -922
24 changed files with 1989 additions and 922 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.env.test
View file

@ -4,4 +4,3 @@ APP_SECRET='$ecretf0rt3st'
SYMFONY_DEPRECATIONS_HELPER=999999 SYMFONY_DEPRECATIONS_HELPER=999999
PANTHER_APP_ENV=panther PANTHER_APP_ENV=panther
PANTHER_ERROR_SCREENSHOT_DIR=./var/error-screenshots PANTHER_ERROR_SCREENSHOT_DIR=./var/error-screenshots
DATABASE_URL="sqlite:///%kernel.project_dir%/var/test-data.db"

19
.gitignore vendored
View file

@ -1,4 +1,3 @@
###> symfony/framework-bundle ### ###> symfony/framework-bundle ###
/.env.local /.env.local
/.env.local.php /.env.local.php
@ -8,17 +7,13 @@
/var/ /var/
/vendor/ /vendor/
###< symfony/framework-bundle ### ###< symfony/framework-bundle ###
###> symfony/phpunit-bridge ###
.phpunit.result.cache
/phpunit.xml
###< symfony/phpunit-bridge ###
###> phpunit/phpunit ###
/phpunit.xml
.phpunit.result.cache
###< phpunit/phpunit ###
.idea/ .idea/
/deploy/var/ /deploy/var/
/deploy/app/ /deploy/app/
###> phpunit/phpunit ###
.phpunit.result.cache
.phpunit.cache
###< phpunit/phpunit ###
.DS_Store

23
bin/phpunit
View file

@ -1,23 +0,0 @@
#!/usr/bin/env php
<?php
if (!ini_get('date.timezone')) {
ini_set('date.timezone', 'UTC');
}
if (is_file(dirname(__DIR__).'/vendor/phpunit/phpunit/phpunit')) {
if (PHP_VERSION_ID >= 80000) {
require dirname(__DIR__).'/vendor/phpunit/phpunit/phpunit';
} else {
define('PHPUNIT_COMPOSER_INSTALL', dirname(__DIR__).'/vendor/autoload.php');
require PHPUNIT_COMPOSER_INSTALL;
PHPUnit\TextUI\Command::main();
}
} else {
if (!is_file(dirname(__DIR__).'/vendor/symfony/phpunit-bridge/bin/simple-phpunit.php')) {
echo "Unable to find the `simple-phpunit.php` script in `vendor/symfony/phpunit-bridge/bin/`.\n";
exit(1);
}
require dirname(__DIR__).'/vendor/symfony/phpunit-bridge/bin/simple-phpunit.php';
}

10
composer.json
View file

@ -27,21 +27,21 @@
"require-dev": { "require-dev": {
"doctrine/doctrine-fixtures-bundle": "^4.0", "doctrine/doctrine-fixtures-bundle": "^4.0",
"lubiana/code-quality": "^1.7.2", "lubiana/code-quality": "^1.7.2",
"phpunit/phpunit": "^9.6.20", "pestphp/pest": "^3.6",
"symfony/browser-kit": "7.2.*", "symfony/browser-kit": "7.2.*",
"symfony/css-selector": "7.2.*", "symfony/css-selector": "7.2.*",
"symfony/maker-bundle": "^1.60", "symfony/maker-bundle": "^1.60",
"symfony/phpunit-bridge": "7.2.*",
"symfony/stopwatch": "7.2.*", "symfony/stopwatch": "7.2.*",
"symfony/web-profiler-bundle": "7.2.*", "symfony/web-profiler-bundle": "7.2.*",
"symplify/config-transformer": "^12.3.4" "symplify/config-transformer": "^12.3.4"
}, },
"config": { "config": {
"allow-plugins": { "allow-plugins": {
"dealerdirect/phpcodesniffer-composer-installer": true,
"pestphp/pest-plugin": true,
"php-http/discovery": true, "php-http/discovery": true,
"symfony/flex": true, "symfony/flex": true,
"symfony/runtime": true, "symfony/runtime": true
"dealerdirect/phpcodesniffer-composer-installer": true
}, },
"sort-packages": true, "sort-packages": true,
"platform": { "platform": {
@ -85,7 +85,7 @@
"rector", "rector",
"ecs --fix || ecs --fix" "ecs --fix || ecs --fix"
], ],
"test": "bin/phpunit" "test": "pest"
}, },
"conflict": { "conflict": {
"symfony/symfony": "*" "symfony/symfony": "*"

1995
composer.lock generated
View file

File diff suppressed because it is too large Load diff

20
infection.json5
View file

@ -1,20 +0,0 @@
{
"$schema": "vendor/infection/infection/resources/schema.json",
"source": {
"directories": [
"src"
]
},
"timeout": 30,
"logs": {
"text": "var/log/infection.txt",
"summary": "var/log/summary.log",
},
"mutators": {
"@default": true,
"global-ignore": [
"App\\Service\\Favicon::__toString",
"ORM\\Column.*"
]
}
}

38
phpunit.xml Normal file
View file

@ -0,0 +1,38 @@
<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
bootstrap="tests/bootstrap.php"
cacheDirectory=".phpunit.cache"
executionOrder="depends,defects"
shortenArraysForExportThreshold="10"
requireCoverageMetadata="false"
beStrictAboutCoverageMetadata="true"
beStrictAboutOutputDuringTests="true"
displayDetailsOnPhpunitDeprecations="true"
failOnPhpunitDeprecation="true"
failOnRisky="true"
failOnWarning="true">
<testsuites>
<testsuite name="default">
<directory>tests/Feature</directory>
<directory>tests/Unit</directory>
</testsuite>
</testsuites>
<source ignoreIndirectDeprecations="true" restrictNotices="true" restrictWarnings="true">
<include>
<directory>src</directory>
</include>
<exclude>
<file>src/Kernel.php</file>
<file>src/Service/Favicon.php</file>
</exclude>
</source>
<php>
<ini name="display_errors" value="1" />
<ini name="error_reporting" value="-1" />
<server name="KERNEL_CLASS" value="App\Kernel" />
<server name="APP_ENV" value="test" force="true" />
<server name="SHELL_VERBOSITY" value="-1" />
</php>
</phpunit>

7
phpunit.xml.dist
View file

@ -6,9 +6,7 @@
backupGlobals="false" backupGlobals="false"
colors="true" colors="true"
bootstrap="tests/bootstrap.php" bootstrap="tests/bootstrap.php"
convertDeprecationsToExceptions="true" convertDeprecationsToExceptions="false"
executionOrder="random"
resolveDependencies="true"
> >
<php> <php>
<ini name="display_errors" value="1" /> <ini name="display_errors" value="1" />
@ -16,8 +14,7 @@
<server name="APP_ENV" value="test" force="true" /> <server name="APP_ENV" value="test" force="true" />
<server name="SHELL_VERBOSITY" value="-1" /> <server name="SHELL_VERBOSITY" value="-1" />
<server name="SYMFONY_PHPUNIT_REMOVE" value="" /> <server name="SYMFONY_PHPUNIT_REMOVE" value="" />
<server name="SYMFONY_PHPUNIT_VERSION" value="9.6" /> <server name="SYMFONY_PHPUNIT_VERSION" value="9.5" />
<server name="KERNEL_CLASS" value="App\Kernel" />
</php> </php>
<testsuites> <testsuites>

3
src/Form/MenuItemType.php
View file

@ -14,15 +14,12 @@ use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Validator\Constraints\Length; use Symfony\Component\Validator\Constraints\Length;
use Symfony\Component\Validator\Constraints\NotBlank; use Symfony\Component\Validator\Constraints\NotBlank;
use function assert;
final class MenuItemType extends AbstractType final class MenuItemType extends AbstractType
{ {
#[Override] #[Override]
public function buildForm(FormBuilderInterface $builder, array $options): void public function buildForm(FormBuilderInterface $builder, array $options): void
{ {
$item = $options['data']; $item = $options['data'];
assert($item instanceof MenuItem);
$builder->add('name', TextType::class, [ $builder->add('name', TextType::class, [
'constraints' => [ 'constraints' => [

11
src/Kernel.php
View file

@ -8,4 +8,15 @@ use Symfony\Component\HttpKernel\Kernel as BaseKernel;
final class Kernel extends BaseKernel final class Kernel extends BaseKernel
{ {
use MicroKernelTrait; use MicroKernelTrait;
public function __construct(
protected string $environment,
protected bool $debug,
) {
parent::__construct($environment, $debug);
if ($environment === 'test') {
$this->debug = false;
}
}
} }

17
symfony.lock
View file

@ -48,7 +48,7 @@
} }
}, },
"phpunit/phpunit": { "phpunit/phpunit": {
"version": "9.6", "version": "11.4",
"recipe": { "recipe": {
"repo": "github.com/symfony/recipes", "repo": "github.com/symfony/recipes",
"branch": "main", "branch": "main",
@ -122,21 +122,6 @@
"ref": "fadbfe33303a76e25cb63401050439aa9b1a9c7f" "ref": "fadbfe33303a76e25cb63401050439aa9b1a9c7f"
} }
}, },
"symfony/phpunit-bridge": {
"version": "7.1",
"recipe": {
"repo": "github.com/symfony/recipes",
"branch": "main",
"version": "6.3",
"ref": "a411a0480041243d97382cac7984f7dce7813c08"
},
"files": [
".env.test",
"bin/phpunit",
"phpunit.xml.dist",
"tests/bootstrap.php"
]
},
"symfony/routing": { "symfony/routing": {
"version": "7.1", "version": "7.1",
"recipe": { "recipe": {

76
tests/Controller/HomeControllerTest.php
View file

@ -1,76 +0,0 @@
<?php declare(strict_types=1);
namespace App\Tests\Controller;
use App\Tests\DbWebTest;
use Override;
final class HomeControllerTest extends DbWebTest
{
public function testIndex(): void
{
$this->client->request(
'GET',
'/'
);
self::assertResponseStatusCodeSame(302);
self::assertResponseHeaderSame('Location', '/food/order/list');
}
public function testSetUsername(): void
{
$this->client->request(
'GET',
'/username',
);
self::assertResponseStatusCodeSame(200);
$this->client->submitForm('Save', [
'user_name_form[username]' => 'Testing-1',
]);
self::assertResponseStatusCodeSame(302);
self::assertResponseHeaderSame('Location', '/food/order/list');
self::assertResponseCookieValueSame('username', 'Testing-1');
$crawler = $this->client->request(
'GET',
'/username',
);
self::assertResponseStatusCodeSame(200);
$this->assertSame(
$crawler->filter('#user_name_form_username')
->last()
->attr('value', ''),
'Testing-1'
);
}
public function testRemoveUsername(): void
{
$this->client->request(
'GET',
'/username',
);
self::assertResponseStatusCodeSame(200);
$this->client->submitForm('Save', [
'user_name_form[username]' => '',
]);
self::assertResponseStatusCodeSame(302);
self::assertResponseHeaderSame('Location', '/food/order/list');
self::assertResponseCookieValueSame('username', '');
}
#[Override]
public function getEntityClass(): string
{
return '';
}
}

19
tests/DbWebTest.php
View file

@ -17,11 +17,11 @@ use function str_contains;
abstract class DbWebTest extends WebTestCase abstract class DbWebTest extends WebTestCase
{ {
abstract public function getEntityClass(): string;
protected KernelBrowser $client; protected KernelBrowser $client;
protected EntityManagerInterface $manager; protected EntityManagerInterface $manager;
protected EntityRepository $repository; protected EntityRepository $repository;
protected string $entityClass = '';
protected string $path = '';
#[Override] #[Override]
protected function setUp(): void protected function setUp(): void
@ -33,10 +33,6 @@ abstract class DbWebTest extends WebTestCase
->getAllMetadata(); ->getAllMetadata();
$schemaTool->dropDatabase(); $schemaTool->dropDatabase();
$schemaTool->updateSchema($metadata); $schemaTool->updateSchema($metadata);
if ($this->getEntityClass() !== '') {
$this->repository = $this->manager->getRepository($this->getEntityClass());
}
} }
protected function generateOldUlid(int $daysToSubtract = 10): Ulid protected function generateOldUlid(int $daysToSubtract = 10): Ulid
@ -56,4 +52,15 @@ abstract class DbWebTest extends WebTestCase
) )
); );
} }
protected function setEntityClass(string $entityClass): void
{
$this->entityClass = $entityClass;
$this->repository = $this->manager->getRepository($this->entityClass);
}
protected function setPath(string $path): void
{
$this->path = $path;
}
} }

24
tests/Entity/FoodOrderTest.php
View file

@ -1,24 +0,0 @@
<?php declare(strict_types=1);
namespace App\Tests\Entity;
use App\Entity\FoodOrder;
use App\Entity\OrderItem;
use PHPUnit\Framework\TestCase;
final class FoodOrderTest extends TestCase
{
public function testFoodOrder(): void
{
$order = new FoodOrder;
$orderItem = new OrderItem;
$this->assertCount(0, $order->getOrderItems());
$order->addOrderItem($orderItem);
$order->addOrderItem($orderItem);
$this->assertCount(1, $order->getOrderItems());
$this->assertSame($order, $orderItem->getFoodOrder());
$order->removeOrderItem($orderItem);
$this->assertCount(0, $order->getOrderItems());
$this->assertNull($orderItem->getFoodOrder());
}
}

148
tests/Controller/FoodOrderControllerTest.php → tests/Feature/Controller/FoodOrderControllerTest.php
View file

@ -1,45 +1,40 @@
<?php declare(strict_types=1); <?php declare(strict_types=1);
namespace App\Tests\Controller; namespace App\Tests\Feature\Controller;
use App\Controller\FoodOrderController;
use App\Entity\FoodOrder; use App\Entity\FoodOrder;
use App\Entity\FoodVendor; use App\Entity\FoodVendor;
use App\Entity\MenuItem; use App\Entity\MenuItem;
use App\Entity\OrderItem; use App\Entity\OrderItem;
use App\Tests\DbWebTest; use App\Form\FoodOrderType;
use Override; use App\Repository\FoodOrderRepository;
use App\Repository\FoodVendorRepository;
use Symfony\Component\BrowserKit\Cookie; use Symfony\Component\BrowserKit\Cookie;
use Symfony\Component\DomCrawler\Crawler; use Symfony\Component\DomCrawler\Crawler;
use function assert; use function assert;
use function describe;
use function pest;
use function range; use function range;
use function sprintf; use function sprintf;
use function str_ends_with; use function str_ends_with;
use function test;
final class FoodOrderControllerTest extends DbWebTest pest()
{ ->beforeEach(function (): void {
private string $path = '/food/order/'; $this->setEntityClass(FoodOrder::class);
private FoodVendor $vendor; $this->setPath('/food/order/');
$this->repository = $this->manager->getRepository($this->entityClass);
#[Override]
public function setUp(): void
{
parent::setUp();
$this->vendor = new FoodVendor; $this->vendor = new FoodVendor;
$this->vendor->setName('Food Vendor'); $this->vendor->setName('Food Vendor');
$this->manager->persist($this->vendor); $this->manager->persist($this->vendor);
$this->manager->flush(); $this->manager->flush();
} });
#[Override] describe(FoodOrderController::class, function (): void {
public function getEntityClass(): string test('index', function (): void {
{
return FoodOrder::class;
}
public function testIndex(): void
{
$order = new FoodOrder; $order = new FoodOrder;
$order->setFoodVendor($this->vendor); $order->setFoodVendor($this->vendor);
@ -48,17 +43,16 @@ final class FoodOrderControllerTest extends DbWebTest
$this->manager->flush(); $this->manager->flush();
$crawler = $this->client->request('GET', "{$this->path}list"); $crawler = $this->client->request('GET', "{$this->path}list");
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
self::assertPageTitleContains('FoodOrder index'); $this->assertPageTitleContains('FoodOrder index');
$this->assertCount( $this->assertCount(
1, 1,
$crawler->filter('td') $crawler->filter('td')
->reduce(fn(Crawler $node, $i): bool => $node->text() === $this->vendor->getName()), ->reduce(fn(Crawler $node, $i): bool => $node->text() === $this->vendor->getName()),
); );
} });
public function testOrderedItems(): void test('orderedItems', function (): void {
{
$order = new FoodOrder; $order = new FoodOrder;
$order->setFoodVendor($this->vendor); $order->setFoodVendor($this->vendor);
@ -104,7 +98,7 @@ final class FoodOrderControllerTest extends DbWebTest
$this->manager->flush(); $this->manager->flush();
$crawler = $this->client->request('GET', "{$this->path}{$order->getId()}"); $crawler = $this->client->request('GET', "{$this->path}{$order->getId()}");
self::assertResponseIsSuccessful(); $this->assertResponseIsSuccessful();
$tdContent = $crawler->filter( $tdContent = $crawler->filter(
'table.table:nth-child(6) > tbody:nth-child(2) > tr:nth-child(1) > td:nth-child(2)' 'table.table:nth-child(6) > tbody:nth-child(2) > tr:nth-child(1) > td:nth-child(2)'
)->text(); )->text();
@ -117,14 +111,20 @@ final class FoodOrderControllerTest extends DbWebTest
'table.table:nth-child(6) > tbody:nth-child(2) > tr:nth-child(3) > td:nth-child(2)' 'table.table:nth-child(6) > tbody:nth-child(2) > tr:nth-child(3) > td:nth-child(2)'
)->text(); )->text();
$this->assertEquals('C', $tdContent); $this->assertEquals('C', $tdContent);
} });
public function testPaginatedIndex(): void test('paginatedIndex', function (): void {
{ foreach (range(1, 35) as $i) {
$this->generatePaginatedOrders(); $order = new FoodOrder($this->generateOldUlid());
$order->setFoodVendor($this->vendor);
$order->close();
$this->manager->persist($order);
}
$this->manager->flush();
$crawler = $this->client->request('GET', "{$this->path}list"); $crawler = $this->client->request('GET', "{$this->path}list");
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
self::assertPageTitleContains('FoodOrder index'); $this->assertPageTitleContains('FoodOrder index');
$this->assertElementContainsCount( $this->assertElementContainsCount(
$crawler, $crawler,
'td', 'td',
@ -137,20 +137,20 @@ final class FoodOrderControllerTest extends DbWebTest
0, 0,
'next page' 'next page'
); );
} });
/** test('paginatedFirstPage', function (int $page, int $prevPage, int $nextPage, int $items = 10): void {
* @testWith [1, 0, 2] foreach (range(1, 35) as $i) {
* [2, 1, 3] $order = new FoodOrder($this->generateOldUlid());
* [3, 2, 4] $order->setFoodVendor($this->vendor);
* [4, 3, 0, 5] $order->close();
*/ $this->manager->persist($order);
public function testPaginatedFirstPage(int $page, int $prevPage, int $nextPage, int $items = 10): void
{ }
$this->generatePaginatedOrders(); $this->manager->flush();
$crawler = $this->client->request('GET', "{$this->path}list/archive/{$page}"); $crawler = $this->client->request('GET', "{$this->path}list/archive/{$page}");
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
self::assertPageTitleContains('FoodOrder index'); $this->assertPageTitleContains('FoodOrder index');
$this->assertElementContainsCount( $this->assertElementContainsCount(
$crawler, $crawler,
'td', 'td',
@ -172,30 +172,36 @@ final class FoodOrderControllerTest extends DbWebTest
$target = $node->attr('href'); $target = $node->attr('href');
$this->assertTrue(str_ends_with((string) $target, "/{$nextPage}")); $this->assertTrue(str_ends_with((string) $target, "/{$nextPage}"));
} }
} })
->with(
[
[1, 0, 2],
[2, 1, 3],
[3, 2, 4],
[4, 3, 0, 5],
]
);
public function testNew(): void test('new', function (): void {
{
$this->client->getCookieJar() $this->client->getCookieJar()
->set(new Cookie('username', 'Testing-1')); ->set(new Cookie('username', 'Testing-1'));
$this->client->request('GET', sprintf('%snew', $this->path)); $this->client->request('GET', sprintf('%snew', $this->path));
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
$this->client->submitForm('Save', [ $this->client->submitForm('Save', [
'food_order[foodVendor]' => $this->vendor->getId(), 'food_order[foodVendor]' => $this->vendor->getId(),
]); ]);
self::assertResponseRedirects("{$this->path}list"); $this->assertResponseRedirects("{$this->path}list");
self::assertSame(1, $this->repository->count([])); $this->assertSame(1, $this->repository->count([]));
$order = $this->repository->findOneBy([ $order = $this->repository->findOneBy([
'createdBy' => 'Testing-1', 'createdBy' => 'Testing-1',
]); ]);
assert($order instanceof FoodOrder); assert($order instanceof FoodOrder);
} });
public function testOpen(): void test('open', function (): void {
{
$order = new FoodOrder; $order = new FoodOrder;
$order->setFoodVendor($this->vendor); $order->setFoodVendor($this->vendor);
$order->close(); $order->close();
@ -205,13 +211,12 @@ final class FoodOrderControllerTest extends DbWebTest
$this->manager->flush(); $this->manager->flush();
$this->client->request('GET', sprintf('%s%s/open', $this->path, $order->getId())); $this->client->request('GET', sprintf('%s%s/open', $this->path, $order->getId()));
self::assertResponseRedirects("{$this->path}{$order->getId()}"); $this->assertResponseRedirects("{$this->path}{$order->getId()}");
$openOrder = $this->repository->find($order->getId()); $openOrder = $this->repository->find($order->getId());
$this->assertFalse($openOrder->isClosed()); $this->assertFalse($openOrder->isClosed());
} });
public function testClose(): void test('close', function (): void {
{
$order = new FoodOrder; $order = new FoodOrder;
$order->setClosedAt(); $order->setClosedAt();
$order->setFoodVendor($this->vendor); $order->setFoodVendor($this->vendor);
@ -221,20 +226,19 @@ final class FoodOrderControllerTest extends DbWebTest
$this->manager->flush(); $this->manager->flush();
$this->client->request('GET', sprintf('%s%s/close', $this->path, $order->getId())); $this->client->request('GET', sprintf('%s%s/close', $this->path, $order->getId()));
self::assertResponseRedirects("{$this->path}{$order->getId()}"); $this->assertResponseRedirects("{$this->path}{$order->getId()}");
$openOrder = $this->repository->find($order->getId()); $openOrder = $this->repository->find($order->getId());
$this->assertTrue($openOrder->isClosed()); $this->assertTrue($openOrder->isClosed());
} });
private function generatePaginatedOrders(): void })
{ ->covers(
foreach (range(1, 35) as $i) { FoodOrderController::class,
$order = new FoodOrder($this->generateOldUlid()); FoodOrder::class,
$order->setFoodVendor($this->vendor); FoodVendor::class,
$order->close(); FoodOrderRepository::class,
$this->manager->persist($order); MenuItem::class,
OrderItem::class,
} FoodOrderType::class,
$this->manager->flush(); FoodVendorRepository::class
} );
}

87
tests/Controller/FoodVendorControllerTest.php → tests/Feature/Controller/FoodVendorControllerTest.php
View file

@ -1,32 +1,42 @@
<?php declare(strict_types=1); <?php declare(strict_types=1);
namespace App\Tests\Controller; namespace App\Tests\Feature\Controller;
use App\Controller\FoodVendorController;
use App\Entity\FoodOrder;
use App\Entity\FoodVendor; use App\Entity\FoodVendor;
use App\Entity\MenuItem; use App\Entity\MenuItem;
use App\Tests\DbWebTest; use App\Entity\OrderItem;
use Override; use App\Form\FoodOrderType;
use App\Form\FoodVendorType;
use App\Repository\FoodOrderRepository;
use App\Repository\FoodVendorRepository;
use function describe;
use function pest;
use function sprintf; use function sprintf;
use function test;
final class FoodVendorControllerTest extends DbWebTest pest()
{ ->beforeEach(function (): void {
private string $path = '/food/vendor/'; $this->setEntityClass(FoodVendor::class);
$this->setPath('/food/vendor/');
$this->repository = $this->manager->getRepository($this->entityClass);
});
public function testIndex(): void describe(FoodVendorController::class, function (): void {
{ test('index', function (): void {
$this->client->request('GET', $this->path); $this->client->request('GET', $this->path);
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
self::assertPageTitleContains('FoodVendor index'); $this->assertPageTitleContains('FoodVendor index');
} });
public function testNew(): void test('new', function (): void {
{ $this->assertSame(0, $this->repository->count([]));
self::assertSame(0, $this->repository->count([]));
$this->client->request('GET', sprintf('%snew', $this->path)); $this->client->request('GET', sprintf('%snew', $this->path));
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
$this->client->submitForm('Save', [ $this->client->submitForm('Save', [
'food_vendor[name]' => 'TestingNew', 'food_vendor[name]' => 'TestingNew',
@ -36,12 +46,11 @@ final class FoodVendorControllerTest extends DbWebTest
'name' => 'TestingNew', 'name' => 'TestingNew',
]); ]);
$this->assertInstanceof(FoodVendor::class, $newVendor); $this->assertInstanceof(FoodVendor::class, $newVendor);
self::assertSame(1, $this->repository->count([])); $this->assertSame(1, $this->repository->count([]));
} });
public function testShow(): void test('show', function (): void {
{
$fixture = new FoodVendor; $fixture = new FoodVendor;
$fixture->setName('My Title'); $fixture->setName('My Title');
$fixture->setMenuLink('https://example.com/'); $fixture->setMenuLink('https://example.com/');
@ -63,10 +72,9 @@ final class FoodVendorControllerTest extends DbWebTest
)->text(); )->text();
$this->assertSame('My Title', $nameNode); $this->assertSame('My Title', $nameNode);
$this->assertSame('https://example.com/', $menuLinkNode); $this->assertSame('https://example.com/', $menuLinkNode);
} });
public function testShowMenuItems(): void test('show with menu items', function (): void {
{
$fixture = new FoodVendor; $fixture = new FoodVendor;
$fixture->setName('My Title'); $fixture->setName('My Title');
@ -114,10 +122,9 @@ final class FoodVendorControllerTest extends DbWebTest
$itemNodes = $crawler->filter('li'); $itemNodes = $crawler->filter('li');
$this->assertCount(4, $itemNodes); $this->assertCount(4, $itemNodes);
} });
public function testEdit(): void test('edit', function (): void {
{
$fixture = new FoodVendor; $fixture = new FoodVendor;
$fixture->setName('Value'); $fixture->setName('Value');
$fixture->setMenuLink('Value'); $fixture->setMenuLink('Value');
@ -152,18 +159,26 @@ final class FoodVendorControllerTest extends DbWebTest
'food_vendor[phone]' => '1234567890', 'food_vendor[phone]' => '1234567890',
]); ]);
self::assertResponseRedirects('/food/vendor/'); $this->assertResponseRedirects('/food/vendor/');
$fixture = $this->repository->findAll(); $fixture = $this->repository->findAll();
self::assertSame('Something New', $fixture[0]->getName()); $this->assertSame('Something New', $fixture[0]->getName());
self::assertSame('https://example.com/', $fixture[0]->getMenuLink()); $this->assertSame('https://example.com/', $fixture[0]->getMenuLink());
self::assertSame('1234567890', $fixture[0]->getPhone()); $this->assertSame('1234567890', $fixture[0]->getPhone());
} });
#[Override] })
public function getEntityClass(): string ->covers(
{ FoodOrder::class,
return FoodVendor::class; FoodVendor::class,
} FoodOrderRepository::class,
} MenuItem::class,
OrderItem::class,
FoodOrderType::class,
FoodVendorRepository::class,
FoodVendorController::class,
FoodVendorType::class
)
;

71
tests/Feature/Controller/HomeControllerTest.php Normal file
View file

@ -0,0 +1,71 @@
<?php declare(strict_types=1);
namespace App\Tests\Feature\Controller;
use App\Controller\HomeController;
use App\Form\UserNameFormType;
use function describe;
use function test;
describe(HomeController::class, function (): void {
test('index', function (): void {
$this->client->request(
'GET',
'/'
);
$this->assertResponseStatusCodeSame(302);
$this->assertResponseHeaderSame('Location', '/food/order/list');
});
test('username', function (): void {
$this->client->request(
'GET',
'/username',
);
$this->assertResponseStatusCodeSame(200);
$this->client->submitForm('Save', [
'user_name_form[username]' => 'Testing-1',
]);
$this->assertResponseStatusCodeSame(302);
$this->assertResponseHeaderSame('Location', '/food/order/list');
$this->assertResponseCookieValueSame('username', 'Testing-1');
$crawler = $this->client->request(
'GET',
'/username',
);
$this->assertResponseStatusCodeSame(200);
$this->assertSame(
$crawler->filter('#user_name_form_username')
->last()
->attr('value', ''),
'Testing-1'
);
});
test('username empty', function (): void {
$this->client->request(
'GET',
'/username',
);
$this->assertResponseStatusCodeSame(200);
$this->client->submitForm('Save', [
'user_name_form[username]' => '',
]);
$this->assertResponseStatusCodeSame(302);
$this->assertResponseHeaderSame('Location', '/food/order/list');
$this->assertResponseCookieValueSame('username', '');
});
})
->covers(HomeController::class, UserNameFormType::class);

81
tests/Controller/MenuItemControllerTest.php → tests/Feature/Controller/MenuItemControllerTest.php
View file

@ -1,32 +1,34 @@
<?php declare(strict_types=1); <?php declare(strict_types=1);
namespace App\Tests\Controller; namespace App\Tests\Feature\Controller;
use App\Controller\MenuItemController;
use App\Controller\OrderItemController;
use App\Entity\FoodOrder; use App\Entity\FoodOrder;
use App\Entity\FoodVendor; use App\Entity\FoodVendor;
use App\Entity\MenuItem; use App\Entity\MenuItem;
use App\Tests\DbWebTest; use App\Entity\OrderItem;
use Override; use App\Form\MenuItemType;
use App\Form\OrderItemType;
use App\Repository\FoodOrderRepository;
use App\Repository\MenuItemRepository;
use function describe;
use function pest;
use function sprintf; use function sprintf;
use function test;
final class MenuItemControllerTest extends DbWebTest pest()
{ ->beforeEach(function (): void {
private string $path = '/menu/item/'; $this->setEntityClass(MenuItem::class);
private FoodVendor $vendor; $this->setPath('/menu/item/');
private MenuItem $menuItem;
private MenuItem $aliasOne; $this->repository = $this->manager->getRepository($this->entityClass);
private MenuItem $aliasTwo;
#[Override]
public function setUp(): void
{
parent::setUp();
$this->vendor = new FoodVendor; $this->vendor = new FoodVendor;
$this->vendor->setName('Food Vendor'); $this->vendor->setName('Food Vendor');
$this->manager->persist($this->vendor); $this->manager->persist($this->vendor);
$this->menuItem = new MenuItem; $this->menuItem = new MenuItem;
$this->menuItem->setName('Testing 1 2'); $this->menuItem->setName('Testing 1 2');
@ -52,16 +54,10 @@ final class MenuItemControllerTest extends DbWebTest
$this->manager->persist($this->menuItem); $this->manager->persist($this->menuItem);
$this->manager->flush(); $this->manager->flush();
} });
#[Override] describe(MenuItemController::class, function (): void {
public function getEntityClass(): string test('show', function (): void {
{
return MenuItem::class;
}
public function testShow(): void
{
$crawler = $this->client->request('GET', "{$this->path}{$this->menuItem->getId()}"); $crawler = $this->client->request('GET', "{$this->path}{$this->menuItem->getId()}");
$idValue = $crawler->filter( $idValue = $crawler->filter(
@ -77,15 +73,14 @@ final class MenuItemControllerTest extends DbWebTest
$aliasOneNameValue = $crawler->filter( $aliasOneNameValue = $crawler->filter(
'.table > tbody:nth-child(1) > tr:nth-child(3) > td:nth-child(2) > ul:nth-child(1) > li:nth-child(2)' '.table > tbody:nth-child(1) > tr:nth-child(3) > td:nth-child(2) > ul:nth-child(1) > li:nth-child(2)'
)->text(); )->text();
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
$this->assertEquals($idValue, $this->menuItem->getId()); $this->assertEquals($idValue, $this->menuItem->getId());
$this->assertEquals($nameValue, $this->menuItem->getName()); $this->assertEquals($nameValue, $this->menuItem->getName());
$this->assertEquals($aliasTwoNameValue, $this->aliasOne->getName()); $this->assertEquals($aliasTwoNameValue, $this->aliasOne->getName());
$this->assertEquals($aliasOneNameValue, $this->aliasTwo->getName()); $this->assertEquals($aliasOneNameValue, $this->aliasTwo->getName());
} });
public function testEdit(): void test('edit', function (): void {
{
$crawler = $this->client->request('GET', sprintf('%s%s/edit', $this->path, $this->menuItem->getId())); $crawler = $this->client->request('GET', sprintf('%s%s/edit', $this->path, $this->menuItem->getId()));
$nameElem = $crawler->filter('#menu_item_name'); $nameElem = $crawler->filter('#menu_item_name');
$this->assertEquals( $this->assertEquals(
@ -100,16 +95,15 @@ final class MenuItemControllerTest extends DbWebTest
$this->client->submit($form); $this->client->submit($form);
self::assertResponseRedirects(sprintf('/menu/item/%s', $this->menuItem->getId())); $this->assertResponseRedirects(sprintf('/menu/item/%s', $this->menuItem->getId()));
$menuItem = $this->repository->find($this->menuItem->getId()); $menuItem = $this->repository->find($this->menuItem->getId());
$this->assertEquals('Testing-1', $menuItem->getName()); $this->assertEquals('Testing-1', $menuItem->getName());
$this->assertEquals(1, $menuItem->getAliases()->count()); $this->assertEquals(1, $menuItem->getAliases()->count());
$aliasOne = $this->repository->find($this->aliasOne->getId()); $aliasOne = $this->repository->find($this->aliasOne->getId());
$this->assertNull($aliasOne->getAliasOf()); $this->assertNull($aliasOne->getAliasOf());
} });
public function testEditInvalid(): void test('edit invalid', function (): void {
{
$crawler = $this->client->request('GET', sprintf('%s%s/edit', $this->path, $this->menuItem->getId())); $crawler = $this->client->request('GET', sprintf('%s%s/edit', $this->path, $this->menuItem->getId()));
$nameElem = $crawler->filter('#menu_item_name'); $nameElem = $crawler->filter('#menu_item_name');
$this->assertEquals( $this->assertEquals(
@ -123,11 +117,10 @@ final class MenuItemControllerTest extends DbWebTest
$this->client->submit($form); $this->client->submit($form);
self::assertResponseStatusCodeSame(422); $this->assertResponseStatusCodeSame(422);
} });
public function testDelete(): void test('delete', function (): void {
{
$order = new FoodOrder; $order = new FoodOrder;
$order->setFoodVendor($this->vendor); $order->setFoodVendor($this->vendor);
@ -150,5 +143,17 @@ final class MenuItemControllerTest extends DbWebTest
$this->assertResponseIsSuccessful(); $this->assertResponseIsSuccessful();
} });
} })
->covers(
MenuItemController::class,
OrderItemController::class,
OrderItemType::class,
MenuItemRepository::class,
FoodOrder::class,
FoodVendor::class,
MenuItem::class,
OrderItem::class,
FoodOrderRepository::class,
MenuItemType::class,
);

135
tests/Controller/OrderItemControllerTest.php → tests/Feature/Controller/OrderItemControllerTest.php
View file

@ -1,30 +1,29 @@
<?php declare(strict_types=1); <?php declare(strict_types=1);
namespace App\Tests\Controller; namespace App\Tests\Feature\Controller;
use App\Controller\OrderItemController;
use App\Entity\FoodOrder; use App\Entity\FoodOrder;
use App\Entity\FoodVendor; use App\Entity\FoodVendor;
use App\Entity\MenuItem; use App\Entity\MenuItem;
use App\Entity\OrderItem; use App\Entity\OrderItem;
use App\Form\OrderItemType;
use App\Repository\FoodOrderRepository;
use App\Repository\MenuItemRepository; use App\Repository\MenuItemRepository;
use App\Tests\DbWebTest; use App\Repository\OrderItemRepository;
use DateTimeImmutable; use DateTimeImmutable;
use Override;
use function describe;
use function pest;
use function sprintf; use function sprintf;
use function test;
final class OrderItemControllerTest extends DbWebTest pest()
{ ->beforeEach(function (): void {
public FoodVendor $vendor; $this->setEntityClass(OrderItem::class);
public FoodOrder $order; $this->setPath('/order/item/');
public Menuitem $menuItem; $this->repository = $this->manager->getRepository($this->entityClass);
public MenuItemRepository $menuItemRepository;
private string $path = '/order/item/';
#[Override]
public function setUp(): void
{
parent::setUp();
$this->vendor = new FoodVendor; $this->vendor = new FoodVendor;
$this->vendor->setName('Food Vendor'); $this->vendor->setName('Food Vendor');
@ -51,11 +50,11 @@ final class OrderItemControllerTest extends DbWebTest
$this->manager->persist($this->menuItem); $this->manager->persist($this->menuItem);
$this->manager->flush(); $this->manager->flush();
$this->menuItemRepository = static::getContainer()->get(MenuItemRepository::class); $this->menuItemRepository = $this::getContainer()->get(MenuItemRepository::class);
} });
public function testNew(): void describe(OrderItemController::class, function (): void {
{ test('new', function (): void {
$crawler = $this->client->request( $crawler = $this->client->request(
'GET', 'GET',
sprintf('%snew/%s', $this->path, $this->order->getId()) sprintf('%snew/%s', $this->path, $this->order->getId())
@ -66,23 +65,22 @@ final class OrderItemControllerTest extends DbWebTest
$this->assertCount(1, $children); $this->assertCount(1, $children);
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
$this->client->submitForm('Save', [ $this->client->submitForm('Save', [
'order_item[name]' => 'Testing', 'order_item[name]' => 'Testing',
'order_item[extras]' => 'Testing', 'order_item[extras]' => 'Testing',
]); ]);
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
self::assertSame(1, $this->repository->count([])); $this->assertSame(1, $this->repository->count([]));
self::assertSame(1, $this->menuItemRepository->count([ $this->assertSame(1, $this->menuItemRepository->count([
'foodVendor' => $this->vendor->getId(), 'foodVendor' => $this->vendor->getId(),
])); ]));
} });
public function testNewOrderClosed(): void test('new order closed', function (): void {
{
$this->order->setClosedAt(new DateTimeImmutable('-1 Hour')); $this->order->setClosedAt(new DateTimeImmutable('-1 Hour'));
$this->manager->persist($this->order); $this->manager->persist($this->order);
@ -93,33 +91,31 @@ final class OrderItemControllerTest extends DbWebTest
sprintf('%snew/%s', $this->path, $this->order->getId()) sprintf('%snew/%s', $this->path, $this->order->getId())
); );
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
self::assertSame(0, $this->repository->count([])); $this->assertSame(0, $this->repository->count([]));
} });
public function testNewCreateMenuItem(): void test('new create menu item', function (): void {
{
$this->client->request( $this->client->request(
'GET', 'GET',
sprintf('%snew/%s', $this->path, $this->order->getId()) sprintf('%snew/%s', $this->path, $this->order->getId())
); );
self::assertResponseStatusCodeSame(200); $this->assertResponseStatusCodeSame(200);
$this->client->submitForm('Save', [ $this->client->submitForm('Save', [
'order_item[name]' => 'Testing-1', 'order_item[name]' => 'Testing-1',
'order_item[extras]' => 'Testing-1', 'order_item[extras]' => 'Testing-1',
]); ]);
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
self::assertSame(1, $this->repository->count([])); $this->assertSame(1, $this->repository->count([]));
self::assertSame(3, $this->menuItemRepository->count([])); $this->assertSame(3, $this->menuItemRepository->count([]));
} });
public function testRemove(): void test('remove', function (): void {
{
$fixture = new OrderItem; $fixture = new OrderItem;
$fixture->setName('Testing'); $fixture->setName('Testing');
$fixture->setExtras('Value'); $fixture->setExtras('Value');
@ -132,12 +128,11 @@ final class OrderItemControllerTest extends DbWebTest
$this->client->request('GET', sprintf('%sdelete/%s', $this->path, $fixture->getId())); $this->client->request('GET', sprintf('%sdelete/%s', $this->path, $fixture->getId()));
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
self::assertSame(0, $this->repository->count([])); $this->assertSame(0, $this->repository->count([]));
} });
public function testOrderClosed(): void test('order closed', function (): void {
{
$fixture = new OrderItem; $fixture = new OrderItem;
$fixture->setName('Testing'); $fixture->setName('Testing');
$fixture->setExtras('Value'); $fixture->setExtras('Value');
@ -152,12 +147,11 @@ final class OrderItemControllerTest extends DbWebTest
$this->client->request('GET', sprintf('%sdelete/%s', $this->path, $fixture->getId())); $this->client->request('GET', sprintf('%sdelete/%s', $this->path, $fixture->getId()));
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
self::assertSame(1, $this->repository->count([])); $this->assertSame(1, $this->repository->count([]));
} });
public function testEdit(): void test('edit', function (): void {
{
$orderItem = new OrderItem; $orderItem = new OrderItem;
$orderItem->setName('Testing'); $orderItem->setName('Testing');
$orderItem->setExtras('My Extra'); $orderItem->setExtras('My Extra');
@ -185,15 +179,14 @@ final class OrderItemControllerTest extends DbWebTest
'order_item[extras]' => 'Testing-1', 'order_item[extras]' => 'Testing-1',
]); ]);
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
self::assertSame(1, $this->repository->count([])); $this->assertSame(1, $this->repository->count([]));
self::assertSame(3, $this->menuItemRepository->count([])); $this->assertSame(3, $this->menuItemRepository->count([]));
} });
public function testEditOrderClosed(): void test('edit order closed', function (): void {
{
$orderItem = new OrderItem; $orderItem = new OrderItem;
$orderItem->setName('Testing'); $orderItem->setName('Testing');
$orderItem->setExtras('My Extra'); $orderItem->setExtras('My Extra');
@ -207,11 +200,10 @@ final class OrderItemControllerTest extends DbWebTest
$this->manager->flush(); $this->manager->flush();
$this->client->request('GET', sprintf('%s%s/edit', $this->path, $orderItem->getId())); $this->client->request('GET', sprintf('%s%s/edit', $this->path, $orderItem->getId()));
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
} });
public function testCopy(): void test('copy', function (): void {
{
$orderItem = new OrderItem; $orderItem = new OrderItem;
$orderItem->setName('My Title'); $orderItem->setName('My Title');
$orderItem->setExtras('My Title'); $orderItem->setExtras('My Title');
@ -222,7 +214,7 @@ final class OrderItemControllerTest extends DbWebTest
$this->manager->flush(); $this->manager->flush();
$this->client->request('GET', sprintf('%s%s/copy', $this->path, $orderItem->getId())); $this->client->request('GET', sprintf('%s%s/copy', $this->path, $orderItem->getId()));
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
$result = $this->repository->findBy([ $result = $this->repository->findBy([
'foodOrder' => $this->order->getId(), 'foodOrder' => $this->order->getId(),
@ -232,10 +224,9 @@ final class OrderItemControllerTest extends DbWebTest
$this->assertSame($orderItem->getName(), $item->getName()); $this->assertSame($orderItem->getName(), $item->getName());
$this->assertSame($orderItem->getExtras(), $item->getExtras()); $this->assertSame($orderItem->getExtras(), $item->getExtras());
} }
} });
public function testCopyOrderClosed(): void test('copy order closed', function (): void {
{
$orderItem = new OrderItem; $orderItem = new OrderItem;
$orderItem->setName('My Title'); $orderItem->setName('My Title');
$orderItem->setExtras('My Title'); $orderItem->setExtras('My Title');
@ -248,17 +239,23 @@ final class OrderItemControllerTest extends DbWebTest
$this->manager->flush(); $this->manager->flush();
$this->client->request('GET', sprintf('%s%s/copy', $this->path, $orderItem->getId())); $this->client->request('GET', sprintf('%s%s/copy', $this->path, $orderItem->getId()));
self::assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId())); $this->assertResponseRedirects(sprintf('/food/order/%s', $this->order->getId()));
$result = $this->repository->findBy([ $result = $this->repository->findBy([
'foodOrder' => $this->order->getId(), 'foodOrder' => $this->order->getId(),
]); ]);
$this->assertCount(1, $result); $this->assertCount(1, $result);
} });
#[Override] })
public function getEntityClass(): string ->covers(
{ OrderItemController::class,
return OrderItem::class; MenuItemRepository::class,
} OrderItemRepository::class,
} OrderItemType::class,
FoodOrder::class,
FoodVendor::class,
MenuItem::class,
OrderItem::class,
FoodOrderRepository::class,
);

33
tests/Pest.php Normal file
View file

@ -0,0 +1,33 @@
<?php declare(strict_types=1);
use App\Tests\DbWebTest;
/*
|--------------------------------------------------------------------------
| Test Case
|--------------------------------------------------------------------------
|
| The closure you provide to your test functions is always bound to a specific PHPUnit test
| case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
| need to change it using the "pest()" function to bind a different classes or traits.
|
*/
pest()
->extends(DbWebTest::class)->in('Feature/Controller/*.php');
/*
|--------------------------------------------------------------------------
| Functions
|--------------------------------------------------------------------------
|
| While Pest is very powerful out-of-the-box, you may have some testing code specific to your
| project that you don't want to repeat in every file. Here you can also expose helpers as
| global functions to help you to reduce the number of lines of code in your test files.
|
*/
function something(): void
{
// ..
}

10
tests/TestCase.php Normal file
View file

@ -0,0 +1,10 @@
<?php declare(strict_types=1);
namespace Tests;
use PHPUnit\Framework\TestCase as BaseTestCase;
abstract class TestCase extends BaseTestCase
{
//
}

32
tests/Unit/Entity/FoodOrderTest.php Normal file
View file

@ -0,0 +1,32 @@
<?php declare(strict_types=1);
namespace App\Tests\Unit\Entity;
use App\Entity\FoodOrder;
use App\Entity\OrderItem;
use function expect;
use function test;
test('FoodOrder Entity', function (): void {
$order = new FoodOrder;
$orderItem = new OrderItem;
expect($order->getOrderItems())
->toBeEmpty();
$order->addOrderItem($orderItem);
$order->addOrderItem($orderItem);
expect($order->getOrderItems())
->toHaveCount(1)
->and($orderItem->getFoodOrder())
->toBe($order);
$order->removeOrderItem($orderItem);
expect($order->getOrderItems())
->toBeEmpty()
->and($orderItem->getFoodOrder())
->toBeNull();
})
->covers(FoodOrder::class, OrderItem::class);

28
tests/Entity/FoodVendorTest.php → tests/Unit/Entity/FoodVendorTest.php
View file

@ -1,17 +1,17 @@
<?php declare(strict_types=1); <?php declare(strict_types=1);
namespace App\Tests\Entity; namespace App\Tests\Unit\Entity;
use App\Entity\FoodOrder; use App\Entity\FoodOrder;
use App\Entity\FoodVendor; use App\Entity\FoodVendor;
use App\Entity\MenuItem; use App\Entity\MenuItem;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Uid\Ulid; use Symfony\Component\Uid\Ulid;
final class FoodVendorTest extends TestCase use function describe;
{ use function test;
public function testFoodVendor(): void
{ describe(FoodVendor::class, function (): void {
test('FoodVendor entity', function (): void {
$vendor = new FoodVendor; $vendor = new FoodVendor;
$vendor->setName('Test'); $vendor->setName('Test');
$this->assertEquals('Test', $vendor->getName()); $this->assertEquals('Test', $vendor->getName());
@ -29,11 +29,9 @@ final class FoodVendorTest extends TestCase
$vendor->removeFoodOrder($order1); $vendor->removeFoodOrder($order1);
$this->assertCount(0, $vendor->getFoodOrders()); $this->assertCount(0, $vendor->getFoodOrders());
$this->assertNull($order1->getFoodVendor()); $this->assertNull($order1->getFoodVendor());
});
} test('MenutItem entity', function (): void {
public function testMenuItem(): void
{
$vendor = new FoodVendor; $vendor = new FoodVendor;
$menuItem1 = new MenuItem; $menuItem1 = new MenuItem;
$menuItem2 = new MenuItem; $menuItem2 = new MenuItem;
@ -49,10 +47,9 @@ final class FoodVendorTest extends TestCase
$vendor->addMenuItem($menuItem2); $vendor->addMenuItem($menuItem2);
$this->assertCount(1, $vendor->getMenuItems()); $this->assertCount(1, $vendor->getMenuItems());
$this->assertCount(2, $vendor->getMenuItems(true)); $this->assertCount(2, $vendor->getMenuItems(true));
} });
public function testRemoveForeignMenuItem(): void test('remove foreign menu item', function (): void {
{
$vendor1 = new FoodVendor; $vendor1 = new FoodVendor;
$vendor2 = new FoodVendor; $vendor2 = new FoodVendor;
$item1 = new MenuItem; $item1 = new MenuItem;
@ -62,5 +59,6 @@ final class FoodVendorTest extends TestCase
$vendor2->removeMenuItem($item1); $vendor2->removeMenuItem($item1);
$this->assertCount(1, $vendor1->getMenuItems()); $this->assertCount(1, $vendor1->getMenuItems());
$this->assertSame($vendor1, $item1->getFoodVendor()); $this->assertSame($vendor1, $item1->getFoodVendor());
} });
}
})->covers(FoodVendor::class, FoodOrder::class, MenuItem::class);

23
tests/Entity/MenuItemTest.php → tests/Unit/Entity/MenuItemTest.php
View file

@ -1,16 +1,16 @@
<?php declare(strict_types=1); <?php declare(strict_types=1);
namespace App\Tests\Entity; namespace App\Tests\Unit\Entity;
use App\Entity\FoodVendor; use App\Entity\FoodVendor;
use App\Entity\MenuItem; use App\Entity\MenuItem;
use DateTimeImmutable; use DateTimeImmutable;
use PHPUnit\Framework\TestCase;
final class MenuItemTest extends TestCase use function describe;
{ use function test;
public function testMenuItem(): void
{ describe(MenuItem::class, function (): void {
test('MenuItem entity', function (): void {
$item = new MenuItem; $item = new MenuItem;
$item->setName('Test'); $item->setName('Test');
$this->assertEquals('Test', $item->getName()); $this->assertEquals('Test', $item->getName());
@ -26,10 +26,8 @@ final class MenuItemTest extends TestCase
$item->delete(); $item->delete();
$this->assertTrue($item->isDeleted()); $this->assertTrue($item->isDeleted());
$this->assertInstanceOf(DateTimeImmutable::class, $item->getDeletedAt()); $this->assertInstanceOf(DateTimeImmutable::class, $item->getDeletedAt());
} });
test('MenuItem alias', function (): void {
public function testMenuItemAlias(): void
{
$item = new MenuItem; $item = new MenuItem;
$item->setName('Test'); $item->setName('Test');
$this->assertEquals('Test', $item->getName()); $this->assertEquals('Test', $item->getName());
@ -51,6 +49,5 @@ final class MenuItemTest extends TestCase
$item->removeAlias($item2); $item->removeAlias($item2);
$this->assertCount(0, $item->getAliases()); $this->assertCount(0, $item->getAliases());
$this->assertNull($item2->getAliasOf()); $this->assertNull($item2->getAliasOf());
});
} })->covers(MenuItem::class, FoodVendor::class);
}