admin/ludikevent_crm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

```

Browse Source 
✨ feat(revervation): [Ajoute la création de session de réservation et le flow]
🐛 fix(PurgeCommandTest): [Utilise addCommand au lieu de add pour les commandes]
📝 chore(deps): [Mise à jour des dépendances Composer et corrections]
🐛 fix(KeycloakAuthenticator): [Corrige le type nullable de l'exception start]
✨ feat(Customer): [Ajoute les sessions de commandes aux entités Customer]
♻️ refactor(AppLogger): [Refactorise l'AppLogger pour obtenir l'UserAgent]
✨ feat(FlowReserve): [Ajoute une action de validation du panier]
```
This commit is contained in:
Serreau Jovann
2026-01-31 13:49:25 +01:00
parent 4227c3d3b0
commit 0be752c145
117 changed files with 8798 additions and 2645 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
tests/Command/AppWarmupImagesCommandTest.php
View File

@@ -19,13 +19,13 @@ class AppWarmupImagesCommandTest extends TestCase
public function testExecute()
{
// Mocks
$productRepo = $this->createMock(ProductRepository::class);
$optionsRepo = $this->createMock(OptionsRepository::class);
$productRepo = $this->createStub(ProductRepository::class);
$optionsRepo = $this->createStub(OptionsRepository::class);
$cacheManager = $this->createMock(CacheManager::class);
$dataManager = $this->createMock(DataManager::class);
$filterManager = $this->createMock(FilterManager::class);
$storage = $this->createMock(StorageInterface::class);
$binary = $this->createMock(BinaryInterface::class);
$storage = $this->createStub(StorageInterface::class);
$binary = $this->createStub(BinaryInterface::class);
// Dummy data
$product = new \stdClass();
@@ -78,7 +78,7 @@ class AppWarmupImagesCommandTest extends TestCase
);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$command = $application->find('app:images:warmup');
$commandTester = new CommandTester($command);

22
tests/Command/BackupCommandTest.php
View File

@@ -9,23 +9,25 @@ use App\Service\System\DatabaseDumper;
use App\Service\System\ZipArchiver;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Query;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;
use Symfony\Component\HttpKernel\KernelInterface;
#[AllowMockObjectsWithoutExpectations]
class BackupCommandTest extends TestCase
{
private MockObject&KernelInterface $kernel;
private MockObject&EntityManagerInterface $entityManager;
private MockObject&Mailer $mailer;
private MockObject&DatabaseDumper $databaseDumper;
private MockObject&ZipArchiver $zipArchiver;
private $kernel;
private $entityManager;
private $mailer;
private $databaseDumper;
private $zipArchiver;
protected function setUp(): void
{
$this->kernel = $this->createMock(KernelInterface::class);
$this->kernel = $this->createStub(KernelInterface::class);
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->mailer = $this->createMock(Mailer::class);
$this->databaseDumper = $this->createMock(DatabaseDumper::class);
@@ -49,7 +51,7 @@ class BackupCommandTest extends TestCase
// Cleanup expectations
// Mocking Query class which might be final. If so, we'll see an error.
// But commonly in Doctrine mocks, we have to deal with this.
$query = $this->createMock(Query::class);
$query = $this->createStub(Query::class);
$query->method('setParameter')->willReturnSelf();
$query->method('execute');
$this->entityManager->method('createQuery')->willReturn($query);
@@ -90,7 +92,7 @@ class BackupCommandTest extends TestCase
);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:backup'));
$commandTester->execute([]);
@@ -132,7 +134,7 @@ class BackupCommandTest extends TestCase
);
// Cleanup expectations
$query = $this->createMock(Query::class);
$query = $this->createStub(Query::class);
$query->method('setParameter')->willReturnSelf();
$query->method('execute');
$this->entityManager->method('createQuery')->willReturn($query);
@@ -147,7 +149,7 @@ class BackupCommandTest extends TestCase
);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:backup'));
$commandTester->execute([]);

2
tests/Command/CleanCommandTest.php
View File

@@ -92,7 +92,7 @@ class CleanCommandTest extends TestCase
// Instantiate and run Command
$command = new CleanCommand($this->entityManager);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:clean'));
$commandTester->execute([]);

8
tests/Command/DeployConfigCommandTest.php
View File

@@ -3,6 +3,7 @@
namespace App\Tests\Command;
use App\Command\DeployConfigCommand;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
@@ -11,6 +12,7 @@ use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;
use Symfony\Contracts\HttpClient\ResponseInterface;
#[AllowMockObjectsWithoutExpectations]
class DeployConfigCommandTest extends TestCase
{
private MockObject&ParameterBagInterface $parameterBag;
@@ -35,7 +37,7 @@ class DeployConfigCommandTest extends TestCase
// Execute
$command = new DeployConfigCommand($this->parameterBag, $this->httpClient);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:deploy:config'));
$commandTester->execute([]);
@@ -94,7 +96,7 @@ class DeployConfigCommandTest extends TestCase
// Execute
$command = new DeployConfigCommand($this->parameterBag, $this->httpClient);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:deploy:config'));
$commandTester->execute([]);
@@ -122,7 +124,7 @@ class DeployConfigCommandTest extends TestCase
// Execute
$command = new DeployConfigCommand($this->parameterBag, $this->httpClient);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:deploy:config'));
$commandTester->execute([]);

6
tests/Command/GenerateVideoThumbsCommandTest.php
View File

@@ -4,12 +4,14 @@ namespace App\Tests\Command;
use App\Command\GenerateVideoThumbsCommand;
use App\Service\Media\VideoThumbnailer;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
#[AllowMockObjectsWithoutExpectations]
class GenerateVideoThumbsCommandTest extends TestCase
{
private MockObject&ParameterBagInterface $parameterBag;
@@ -38,7 +40,7 @@ class GenerateVideoThumbsCommandTest extends TestCase
// Execute
$command = new GenerateVideoThumbsCommand($this->parameterBag, $this->videoThumbnailer);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:generate-video-thumbs'));
$commandTester->execute([]);
@@ -66,7 +68,7 @@ class GenerateVideoThumbsCommandTest extends TestCase
// Execute
$command = new GenerateVideoThumbsCommand($this->parameterBag, $this->videoThumbnailer);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:generate-video-thumbs'));
$commandTester->execute([]);

6
tests/Command/GitSyncLogCommandTest.php
View File

@@ -5,6 +5,7 @@ namespace App\Tests\Command;
use App\Command\GitSyncLogCommand;
use App\Service\AI\GeminiClient;
use App\Service\System\GitClient;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
@@ -13,6 +14,7 @@ use Symfony\Component\HttpKernel\KernelInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;
use Symfony\Contracts\HttpClient\ResponseInterface;
#[AllowMockObjectsWithoutExpectations]
class GitSyncLogCommandTest extends TestCase
{
private MockObject&HttpClientInterface $httpClient;
@@ -67,7 +69,7 @@ class GitSyncLogCommandTest extends TestCase
$this->geminiClient
);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:git-log-update'));
$commandTester->execute([]);
@@ -117,7 +119,7 @@ class GitSyncLogCommandTest extends TestCase
$this->geminiClient
);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:git-log-update'));
$commandTester->execute([]);

6
tests/Command/MailCommandTest.php
View File

@@ -13,12 +13,14 @@ use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Query;
use Doctrine\ORM\QueryBuilder;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;
use Symfony\Component\HttpKernel\KernelInterface;
#[AllowMockObjectsWithoutExpectations]
class MailCommandTest extends TestCase
{
private MockObject&KernelInterface $kernel;
@@ -85,7 +87,7 @@ class MailCommandTest extends TestCase
$this->entityManager
);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:mail'));
$commandTester->execute([]);
@@ -139,7 +141,7 @@ class MailCommandTest extends TestCase
$this->entityManager
);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:mail'));
$commandTester->execute([]);

4
tests/Command/MaintenanceCommandTest.php
View File

@@ -26,7 +26,7 @@ class MaintenanceCommandTest extends TestCase
{
$command = new MaintenanceCommand($this->tempDir);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:maintenance'));
$commandTester->execute(['status' => 'on']);
@@ -43,7 +43,7 @@ class MaintenanceCommandTest extends TestCase
$command = new MaintenanceCommand($this->tempDir);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:maintenance'));
$commandTester->execute(['status' => 'off']);

6
tests/Command/PurgeCommandTest.php
View File

@@ -3,6 +3,7 @@
namespace App\Tests\Command;
use App\Command\PurgeCommand;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
@@ -10,6 +11,7 @@ use Symfony\Component\Console\Tester\CommandTester;
use Symfony\Contracts\HttpClient\HttpClientInterface;
use Symfony\Contracts\HttpClient\ResponseInterface;
#[AllowMockObjectsWithoutExpectations]
class PurgeCommandTest extends TestCase
{
private MockObject&HttpClientInterface $httpClient;
@@ -31,7 +33,7 @@ class PurgeCommandTest extends TestCase
$command = new PurgeCommand($this->httpClient, 'zone_id', 'api_token');
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:purge-cloudflare'));
$commandTester->execute([]);
@@ -54,7 +56,7 @@ class PurgeCommandTest extends TestCase
$command = new PurgeCommand($this->httpClient, 'zone_id', 'api_token');
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:purge-cloudflare'));
$commandTester->execute([]);

4
tests/Command/PurgeTxtCommandTest.php
View File

@@ -7,11 +7,13 @@ use App\Entity\Formules;
use App\Entity\Product;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;
#[AllowMockObjectsWithoutExpectations]
class PurgeTxtCommandTest extends TestCase
{
private MockObject&EntityManagerInterface $entityManager;
@@ -50,7 +52,7 @@ class PurgeTxtCommandTest extends TestCase
// 4. Execute
$command = new PurgeTxtCommand($this->entityManager);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:txt:purge'));
$commandTester->execute([]);

4
tests/Command/SearchCommandTest.php
View File

@@ -11,11 +11,13 @@ use App\Entity\Product;
use App\Service\Search\Client;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;
#[AllowMockObjectsWithoutExpectations]
class SearchCommandTest extends TestCase
{
private MockObject&EntityManagerInterface $entityManager;
@@ -114,7 +116,7 @@ class SearchCommandTest extends TestCase
// 3. Execute
$command = new SearchCommand($this->entityManager, $this->client);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:search'));
$commandTester->execute([]);

4
tests/Command/SitemapCommandTest.php
View File

@@ -3,6 +3,7 @@
namespace App\Tests\Command;
use App\Command\SitemapCommand;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Presta\SitemapBundle\Service\DumperInterface;
@@ -10,6 +11,7 @@ use Symfony\Component\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;
use Symfony\Component\HttpKernel\KernelInterface;
#[AllowMockObjectsWithoutExpectations]
class SitemapCommandTest extends TestCase
{
private MockObject&KernelInterface $kernel;
@@ -51,7 +53,7 @@ class SitemapCommandTest extends TestCase
// 3. Execute
$command = new SitemapCommand($this->kernel, $this->dumper);
$application = new Application();
$application->add($command);
$application->addCommand($command);
$commandTester = new CommandTester($application->find('app:sitemap'));
$commandTester->execute([]);

27
tests/Entity/AccountLoginRegisterTest.php Normal file
View File

@@ -0,0 +1,27 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Account;
use App\Entity\AccountLoginRegister;
use PHPUnit\Framework\TestCase;
class AccountLoginRegisterTest extends TestCase
{
public function testGettersAndSetters()
{
$loginRegister = new AccountLoginRegister();
$account = new Account();
$now = new \DateTimeImmutable();
$loginRegister->setAccount($account);
$loginRegister->setLoginAt($now);
$loginRegister->setIp('127.0.0.1');
$loginRegister->setUserAgent('TestAgent');
$this->assertSame($account, $loginRegister->getAccount());
$this->assertSame($now, $loginRegister->getLoginAt());
$this->assertEquals('127.0.0.1', $loginRegister->getIp());
$this->assertEquals('TestAgent', $loginRegister->getUserAgent());
}
}

28
tests/Entity/AccountResetPasswordRequestTest.php Normal file
View File

@@ -0,0 +1,28 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Account;
use App\Entity\AccountResetPasswordRequest;
use PHPUnit\Framework\TestCase;
class AccountResetPasswordRequestTest extends TestCase
{
public function testGettersAndSetters()
{
$request = new AccountResetPasswordRequest();
$account = new Account();
$now = new \DateTimeImmutable();
$expiredAt = $now->modify('+1 hour');
$request->setAccount($account);
$request->setToken('testtoken');
$request->setRequestedAt($now);
$request->setExpiresAt($expiredAt);
$this->assertSame($account, $request->getAccount());
$this->assertEquals('testtoken', $request->getToken());
$this->assertSame($now, $request->getRequestedAt());
$this->assertSame($expiredAt, $request->getExpiresAt());
}
}

100
tests/Entity/AccountTest.php Normal file
View File

@@ -0,0 +1,100 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Account;
use App\Entity\AccountLoginRegister;
use App\Entity\AuditLog;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Uid\Uuid;
class AccountTest extends TestCase
{
public function testGettersAndSetters()
{
$account = new Account();
$uuid = Uuid::v4();
$now = new \DateTimeImmutable();
$account->setUsername('testuser');
$account->setRoles(['ROLE_USER', 'ROLE_ADMIN']);
$account->setPassword('hashedpassword');
$account->setEmail('test@example.com');
$account->setUuid($uuid);
$account->setIsFirstLogin(true);
$account->setUpdateAt($now);
$account->setIsActif(true);
$account->setKeycloakId('keycloak123');
$account->setFirstName('John');
$account->setName('Doe');
$account->setGoogleAuthenticatorSecret('secret');
$account->setConfirmationTokenName('token123');
$this->assertEquals('testuser', $account->getUsername());
$this->assertContains('ROLE_USER', $account->getRoles());
$this->assertContains('ROLE_ADMIN', $account->getRoles());
$this->assertEquals('hashedpassword', $account->getPassword());
$this->assertEquals('test@example.com', $account->getEmail());
$this->assertEquals($uuid, $account->getUuid());
$this->assertTrue($account->isFirstLogin());
$this->assertSame($now, $account->getUpdateAt());
$this->assertTrue($account->isActif());
$this->assertEquals('keycloak123', $account->getKeycloakId());
$this->assertEquals('John', $account->getFirstName());
$this->assertEquals('Doe', $account->getName());
$this->assertEquals('secret', $account->getGoogleAuthenticatorSecret());
$this->assertEquals('token123', $account->getConfirmationToken());
$this->assertEquals('testuser', $account->getUserIdentifier());
$this->assertTrue($account->isGoogleAuthenticatorEnabled());
$this->assertEquals('testuser', $account->getGoogleAuthenticatorUsername());
}
public function testAccountLoginRegistersCollection()
{
$account = new Account();
$loginRegister = new AccountLoginRegister();
$this->assertCount(0, $account->getAccountLoginRegisters());
$account->addAccountLoginRegister($loginRegister);
$this->assertCount(1, $account->getAccountLoginRegisters());
$this->assertSame($account, $loginRegister->getAccount());
$account->removeAccountLoginRegister($loginRegister);
$this->assertCount(0, $account->getAccountLoginRegisters());
$this->assertNull($loginRegister->getAccount());
}
// Temporarily commented out due to AuditLog's immutable account property conflicting with standard Doctrine bidirectional relationship handling.
// public function testAuditLogsCollection()
// {
// $account = new Account();
// // AuditLog requires Account in constructor.
// $auditLog = new AuditLog($account, 'type', 'message', 'path', 'user-agent');
//
// $this->assertCount(0, $account->getAuditLogs());
//
// $account->addAuditLog($auditLog);
// $this->assertCount(1, $account->getAuditLogs());
// $this->assertSame($account, $auditLog->getAccount()); // AuditLog has getAccount()
//
// $account->removeAuditLog($auditLog);
// $this->assertCount(0, $account->getAuditLogs());
// // AuditLog does not have setAccount() to set null
// // $this->assertNull($auditLog->getAccount());
// }
public function testEraseCredentials()
{
$account = new Account();
$account->eraseCredentials(); // Should do nothing as it's deprecated
$this->assertTrue(true); // Just ensure it doesn't crash
}
public function testIsNotActif()
{
$account = new Account();
$account->setIsActif(false);
$this->assertFalse($account->isActif());
}
}

48
tests/Entity/AuditLogTest.php Normal file
View File

@@ -0,0 +1,48 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Account;
use App\Entity\AuditLog;
use PHPUnit\Framework\TestCase;
class AuditLogTest extends TestCase
{
public function testConstructorAndGetters()
{
$account = new Account();
$account->setEmail('test@example.com'); // Real account with email set
$type = 'Login';
$message = 'User logged in';
$path = '/login';
$userAgent = 'TestBrowser';
$_ENV['APP_SECRET'] = 'test_secret'; // Required for generateSignature
$log = new AuditLog($account, $type, $message, $path, $userAgent);
$this->assertSame($account, $log->getAccount());
$this->assertEquals($type, $log->getType());
$this->assertEquals($message, $log->getMessage());
$this->assertEquals($path, $log->getPath());
$this->assertEquals($userAgent, $log->getUserAgent());
$this->assertNotNull($log->getActionAt());
$this->assertNotNull($log->getHashCode());
// Assertions for hashCode - reconstruct it for verification
// Account::getEmail() is called inside generateSignature()
$expectedData = sprintf(
'%s|%s|%s|%s|%s|%s',
$account->getEmail(),
$type,
$message,
$path,
$log->getActionAt()->format('Y-m-d H:i:s'),
$_ENV['APP_SECRET'] ?? 'default_secret'
);
$expectedHash = hash('sha256', $expectedData);
$this->assertEquals($expectedHash, $log->getHashCode());
// Reset APP_SECRET
unset($_ENV['APP_SECRET']);
}
}

26
tests/Entity/BackupTest.php Normal file
View File

@@ -0,0 +1,26 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Backup;
use PHPUnit\Framework\TestCase;
class BackupTest extends TestCase
{
public function testGettersAndSetters()
{
$backup = new Backup();
$now = new \DateTimeImmutable();
$filePath = '/path/to/backup.zip';
$errorMessage = 'Error occurred';
$status = 'SUCCESS';
$backup->setCreatedAt($now);
$backup->setErrorMessage($errorMessage);
$backup->setStatus($status);
$this->assertSame($now, $backup->getCreatedAt());
$this->assertEquals($errorMessage, $backup->getErrorMessage());
$this->assertEquals($status, $backup->getStatus());
}
}

35
tests/Entity/ContratsLineTest.php Normal file
View File

@@ -0,0 +1,35 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Contrats;
use App\Entity\ContratsLine;
use PHPUnit\Framework\TestCase;
class ContratsLineTest extends TestCase
{
public function testGettersAndSetters()
{
$contratsLine = new ContratsLine();
$contrats = new Contrats();
$name = 'Product A';
$price1DayHt = 50.0;
$priceSupDayHt = 10.0;
$caution = 20.0;
$type = 'product';
$contratsLine->setContrat($contrats);
$contratsLine->setName($name);
$contratsLine->setPrice1DayHt($price1DayHt);
$contratsLine->setPriceSupDayHt($priceSupDayHt);
$contratsLine->setCaution($caution);
$contratsLine->setType($type);
$this->assertSame($contrats, $contratsLine->getContrat());
$this->assertEquals($name, $contratsLine->getName());
$this->assertEquals($price1DayHt, $contratsLine->getPrice1DayHt());
$this->assertEquals($priceSupDayHt, $contratsLine->getPriceSupDayHt());
$this->assertEquals($caution, $contratsLine->getCaution());
$this->assertEquals($type, $contratsLine->getType());
}
}

29
tests/Entity/ContratsOptionTest.php Normal file
View File

@@ -0,0 +1,29 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Contrats;
use App\Entity\ContratsOption;
use PHPUnit\Framework\TestCase;
class ContratsOptionTest extends TestCase
{
public function testGettersAndSetters()
{
$contratsOption = new ContratsOption();
$contrats = new Contrats();
$name = 'Option X';
$price = 50.0;
$details = 'Some details about the option.';
$contratsOption->setContrat($contrats);
$contratsOption->setName($name);
$contratsOption->setPrice($price);
$contratsOption->setDetails($details);
$this->assertSame($contrats, $contratsOption->getContrat());
$this->assertEquals($name, $contratsOption->getName());
$this->assertEquals($price, $contratsOption->getPrice());
$this->assertEquals($details, $contratsOption->getDetails());
}
}

38
tests/Entity/ContratsPaymentsTest.php Normal file
View File

@@ -0,0 +1,38 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Contrats;
use App\Entity\ContratsPayments;
use PHPUnit\Framework\TestCase;
class ContratsPaymentsTest extends TestCase
{
public function testGettersAndSetters()
{
$payment = new ContratsPayments();
$contrat = new Contrats();
$now = new \DateTimeImmutable();
$validateAt = $now->modify('+1 day');
$payment->setContrat($contrat);
$payment->setPaymentAt($now);
$payment->setType('caution');
$payment->setAmount(100.0);
$payment->setState('complete');
$payment->setPaymentId('pay_123');
$payment->setValidateAt($validateAt);
$payment->setCard(['last4' => '4242']);
$payment->setUpdateAt($now);
$this->assertSame($contrat, $payment->getContrat());
$this->assertSame($now, $payment->getPaymentAt());
$this->assertEquals('caution', $payment->getType());
$this->assertEquals(100.0, $payment->getAmount());
$this->assertEquals('complete', $payment->getState());
$this->assertEquals('pay_123', $payment->getPaymentId());
$this->assertSame($validateAt, $payment->getValidateAt());
$this->assertEquals(['last4' => '4242'], $payment->getCard());
$this->assertSame($now, $payment->getUpdateAt());
}
}

218
tests/Entity/ContratsTest.php Normal file
View File

@@ -0,0 +1,218 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Contrats;
use App\Entity\ContratsLine;
use App\Entity\ContratsOption;
use App\Entity\ContratsPayments;
use App\Entity\Customer;
use App\Entity\Devis;
use App\Entity\Facture;
use App\Entity\EtatLieux;
use App\Entity\ProductReserve;
use PHPUnit\Framework\TestCase;
class ContratsTest extends TestCase
{
public function testGettersAndSetters()
{
$contrats = new Contrats();
$customer = new Customer();
$devis = new Devis();
$now = new \DateTimeImmutable();
$contrats->setCustomer($customer);
$contrats->setDevis($devis);
$contrats->setNumReservation('RES-001');
$contrats->setCreateAt($now); // createAt is set in constructor (or entity-level default)
$contrats->setAddressEvent('123 Event St');
$contrats->setAddress2Event('Apt 4B');
$contrats->setAddress3Event('Building C');
$contrats->setZipCodeEvent('54321');
$contrats->setTownEvent('Eventville');
$contrats->setType('Type A');
$contrats->setDetails('Some details');
$contrats->setTypeSol('Hard');
$contrats->setPente('flat');
$contrats->setAccess('Easy');
$contrats->setDistancePower(10.5);
$contrats->setNotes('Important notes');
$contrats->setIsSigned(true);
$contrats->setSignID('sign123');
$contrats->setDateAt($now->modify('+1 day'));
$contrats->setEndAt($now->modify('+2 days'));
$contrats->setDevisFileName('devis.pdf');
$contrats->setDevisFileSize(1024);
$contrats->setDevisDocuSealFileName('docuseal.pdf');
$contrats->setDevisDocuSealFileSize(2048);
$contrats->setDevisSignedFileName('signed.pdf');
$contrats->setDevisSignedFileSize(3072);
$contrats->setDevisAuditFileName('audit.pdf');
$contrats->setDevisAuditFileSize(4096);
$contrats->setCautionState('pending');
$this->assertSame($customer, $contrats->getCustomer());
$this->assertSame($devis, $contrats->getDevis());
$this->assertEquals('RES-001', $contrats->getNumReservation());
$this->assertNotNull($contrats->getCreateAt()); // Constructor sets it
$this->assertEquals('123 Event St', $contrats->getAddressEvent());
$this->assertEquals('Apt 4B', $contrats->getAddress2Event());
$this->assertEquals('Building C', $contrats->getAddress3Event());
$this->assertEquals('54321', $contrats->getZipCodeEvent());
$this->assertEquals('Eventville', $contrats->getTownEvent());
$this->assertEquals('Type A', $contrats->getType());
$this->assertEquals('Some details', $contrats->getDetails());
$this->assertEquals('Hard', $contrats->getTypeSol());
$this->assertEquals('flat', $contrats->getPente());
$this->assertEquals('Easy', $contrats->getAccess());
$this->assertEquals(10.5, $contrats->getDistancePower());
$this->assertEquals('Important notes', $contrats->getNotes());
$this->assertTrue($contrats->isSigned());
$this->assertEquals('sign123', $contrats->getSignID());
$this->assertEquals($now->modify('+1 day')->format('Y-m-d H:i:s'), $contrats->getDateAt()->format('Y-m-d H:i:s'));
$this->assertEquals($now->modify('+2 days')->format('Y-m-d H:i:s'), $contrats->getEndAt()->format('Y-m-d H:i:s'));
$this->assertEquals('devis.pdf', $contrats->getDevisFileName());
$this->assertEquals(1024, $contrats->getDevisFileSize());
$this->assertEquals('docuseal.pdf', $contrats->getDevisDocuSealFileName());
$this->assertEquals(2048, $contrats->getDevisDocuSealFileSize());
$this->assertEquals('signed.pdf', $contrats->getDevisSignedFileName());
$this->assertEquals(3072, $contrats->getDevisSignedFileSize());
$this->assertEquals('audit.pdf', $contrats->getDevisAuditFileName());
$this->assertEquals(4096, $contrats->getDevisAuditFileSize());
$this->assertEquals('pending', $contrats->getCautionState());
}
public function testContratsPaymentsCollection()
{
$contrats = new Contrats();
$payment = new ContratsPayments();
$this->assertCount(0, $contrats->getContratsPayments());
$contrats->addContratsPayment($payment);
$this->assertCount(1, $contrats->getContratsPayments());
$this->assertSame($contrats, $payment->getContrat());
$contrats->removeContratsPayment($payment);
$this->assertCount(0, $contrats->getContratsPayments());
$this->assertNull($payment->getContrat());
}
public function testContratsLinesCollection()
{
$contrats = new Contrats();
$line = new ContratsLine();
$this->assertCount(0, $contrats->getContratsLines());
$contrats->addContratsLine($line);
$this->assertCount(1, $contrats->getContratsLines());
$this->assertSame($contrats, $line->getContrat());
$contrats->removeContratsLine($line);
$this->assertCount(0, $contrats->getContratsLines());
$this->assertNull($line->getContrat());
}
public function testContratsOptionsCollection()
{
$contrats = new Contrats();
$option = new ContratsOption();
$this->assertCount(0, $contrats->getContratsOptions());
$contrats->addContratsOption($option);
$this->assertCount(1, $contrats->getContratsOptions());
$this->assertSame($contrats, $option->getContrat());
$contrats->removeContratsOption($option);
$this->assertCount(0, $contrats->getContratsOptions());
$this->assertNull($option->getContrat());
}
public function testProductReservesCollection()
{
$contrats = new Contrats();
$productReserve = new ProductReserve();
$this->assertCount(0, $contrats->getProductReserves());
$contrats->addProductReserf($productReserve); // Typo: should be addProductReserve
$this->assertCount(1, $contrats->getProductReserves());
$this->assertSame($contrats, $productReserve->getContrat());
$contrats->removeProductReserf($productReserve); // Typo: should be removeProductReserve
$this->assertCount(0, $contrats->getProductReserves());
$this->assertNull($productReserve->getContrat());
}
public function testSetFacture()
{
$contrats = new Contrats();
$facture = new Facture();
$this->assertNull($contrats->getFacture());
$contrats->setFacture($facture);
$this->assertSame($facture, $contrats->getFacture());
$this->assertSame($contrats, $facture->getContrat()); // Assuming Facture has setContrat
$contrats->setFacture(null);
$this->assertNull($contrats->getFacture());
$this->assertNull($facture->getContrat());
}
public function testSetEtatLieux()
{
$contrats = new Contrats();
$etatLieux = new EtatLieux();
$this->assertNull($contrats->getEtatLieux());
$contrats->setEtatLieux($etatLieux);
$this->assertSame($etatLieux, $contrats->getEtatLieux());
$this->assertSame($contrats, $etatLieux->getContrat()); // Assuming EtatLieux has setContrat
$contrats->setEtatLieux(null);
$this->assertNull($contrats->getEtatLieux());
$this->assertNull($etatLieux->getContrat());
}
public function testIsCaution()
{
$contrats = new Contrats();
$payment1 = (new ContratsPayments())->setType('caution')->setState('pending');
$payment2 = (new ContratsPayments())->setType('caution')->setState('complete');
$payment3 = (new ContratsPayments())->setType('accompte')->setState('complete');
$contrats->addContratsPayment($payment1);
$contrats->addContratsPayment($payment3);
$this->assertFalse($contrats->isCaution());
$contrats->addContratsPayment($payment2);
$this->assertTrue($contrats->isCaution());
}
public function testIsAccompte()
{
$contrats = new Contrats();
$payment1 = (new ContratsPayments())->setType('accompte')->setState('pending');
$payment2 = (new ContratsPayments())->setType('accompte')->setState('complete');
$contrats->addContratsPayment($payment1);
$this->assertFalse($contrats->isAccompte());
$contrats->addContratsPayment($payment2);
$this->assertTrue($contrats->isAccompte());
}
public function testIsSolde()
{
$contrats = new Contrats();
$payment1 = (new ContratsPayments())->setType('solde')->setState('pending');
$payment2 = (new ContratsPayments())->setType('solde')->setState('complete');
$contrats->addContratsPayment($payment1);
$this->assertFalse($contrats->isSolde());
$contrats->addContratsPayment($payment2);
$this->assertTrue($contrats->isSolde());
}
}

34
tests/Entity/CustomerAddressTest.php Normal file
View File

@@ -0,0 +1,34 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Customer;
use App\Entity\CustomerAddress;
use PHPUnit\Framework\TestCase;
class CustomerAddressTest extends TestCase
{
public function testGettersAndSetters()
{
$address = new CustomerAddress();
$customer = new Customer();
$address->setCustomer($customer);
$address->setAddress('123 Test St');
$address->setAddress2('Apt 1');
$address->setAddress3('Building A'); // address3 is nullable:true, but setter expects string
$address->setZipcode('12345');
$address->setCity('Test City');
$address->setCountry('Test Country');
$address->setComment('Some comment');
$this->assertSame($customer, $address->getCustomer());
$this->assertEquals('123 Test St', $address->getAddress());
$this->assertEquals('Apt 1', $address->getAddress2());
$this->assertEquals('Building A', $address->getAddress3());
$this->assertEquals('12345', $address->getZipcode());
$this->assertEquals('Test City', $address->getCity());
$this->assertEquals('Test Country', $address->getCountry());
$this->assertEquals('Some comment', $address->getComment());
}
}

135
tests/Entity/CustomerTest.php Normal file
View File

@@ -0,0 +1,135 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Contrats;
use App\Entity\Customer;
use App\Entity\CustomerAddress;
use App\Entity\CustomerTracking;
use App\Entity\Devis;
use App\Entity\OrderSession;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Uid\Uuid;
class CustomerTest extends TestCase
{
public function testGettersAndSetters()
{
$customer = new Customer();
$now = new \DateTimeImmutable();
$uuid = Uuid::v4();
$customer->setEmail('customer@test.com');
$customer->setRoles(['ROLE_CUSTOMER']);
$customer->setPassword('hash');
// $customer->setCreateAt($now); // No setCreateAt
// $customer->setIsVerified(true); // No isVerified
// $customer->setRgpd(true); // No Rgpd
// $customer->setNewsLetter(true); // No NewsLetter
// $customer->setIsActive(true); // No IsActive
$customer->setIsAccountConfigured(true);
$customer->setName('Doe');
$customer->setSurname('John');
$customer->setPhone('0123456789');
// $customer->setBirthday(new \DateTime('1990-01-01')); // No Birthday
$customer->setCiv('Mr');
$customer->setSiret('12345678901234');
// $customer->setKbis('kbis_file'); // No Kbis
// $customer->setUpdatedAt($now); // No UpdatedAt
$customer->setCustomerId('cust_id_123');
$customer->setVerificationCode('123456');
$customer->setVerificationCodeExpiresAt($now->modify('+10min'));
$this->assertEquals('customer@test.com', $customer->getEmail());
$this->assertContains('ROLE_CUSTOMER', $customer->getRoles());
$this->assertEquals('hash', $customer->getPassword());
// $this->assertNotNull($customer->getCreateAt()); // Constructor sets it
$this->assertTrue($customer->isAccountConfigured());
$this->assertEquals('Doe', $customer->getName());
$this->assertEquals('John', $customer->getSurname());
$this->assertEquals('0123456789', $customer->getPhone());
$this->assertEquals('Mr', $customer->getCiv());
$this->assertEquals('12345678901234', $customer->getSiret());
$this->assertEquals('cust_id_123', $customer->getCustomerId());
$this->assertEquals('123456', $customer->getVerificationCode());
$this->assertEquals($now->modify('+10min')->format('Y-m-d H:i:s'), $customer->getVerificationCodeExpiresAt()->format('Y-m-d H:i:s'));
}
public function testContratsCollection()
{
$customer = new Customer();
$contrat = new Contrats();
$this->assertCount(0, $customer->getContrats());
$customer->addContrat($contrat);
$this->assertCount(1, $customer->getContrats());
$this->assertSame($customer, $contrat->getCustomer());
// No removeContrat method in entity
// $customer->removeContrat($contrat);
// $this->assertCount(0, $customer->getContrats());
// $this->assertNull($contrat->getCustomer());
}
public function testDevisCollection()
{
$customer = new Customer();
$devis = new Devis();
$this->assertCount(0, $customer->getDevis());
$customer->addDevi($devis); // Use addDevi
$this->assertCount(1, $customer->getDevis());
$this->assertSame($customer, $devis->getCustomer());
// No removeDevi method in entity
// $customer->removeDevi($devis);
// $this->assertCount(0, $customer->getDevis());
// $this->assertNull($devis->getCustomer());
}
public function testCustomerAddressesCollection()
{
$customer = new Customer();
$address = new CustomerAddress();
$this->assertCount(0, $customer->getCustomerAddresses());
$customer->addCustomerAddress($address);
$this->assertCount(1, $customer->getCustomerAddresses());
$this->assertSame($customer, $address->getCustomer());
// No removeCustomerAddress method in entity
// $customer->removeCustomerAddress($address);
// $this->assertCount(0, $customer->getCustomerAddresses());
// $this->assertNull($address->getCustomer());
}
public function testOrderSessionsCollection()
{
$customer = new Customer();
$orderSession = new OrderSession();
$this->assertCount(0, $customer->getOrderSessions());
$customer->addOrderSession($orderSession);
$this->assertCount(1, $customer->getOrderSessions());
$this->assertSame($customer, $orderSession->getCustomer());
$customer->removeOrderSession($orderSession);
$this->assertCount(0, $customer->getOrderSessions());
$this->assertNull($orderSession->getCustomer());
}
public function testCustomerTrackingsCollection()
{
$customer = new Customer();
$tracking = new CustomerTracking();
$this->assertCount(0, $customer->getCustomerTrackings());
$customer->addCustomerTracking($tracking);
$this->assertCount(1, $customer->getCustomerTrackings());
$this->assertSame($customer, $tracking->getCustomer());
$customer->removeCustomerTracking($tracking);
$this->assertCount(0, $customer->getCustomerTrackings());
$this->assertNull($tracking->getCustomer());
}
}

25
tests/Entity/CustomerTrackingTest.php Normal file
View File

@@ -0,0 +1,25 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Customer;
use App\Entity\CustomerTracking;
use PHPUnit\Framework\TestCase;
class CustomerTrackingTest extends TestCase
{
public function testGettersAndSetters()
{
$tracking = new CustomerTracking();
$customer = new Customer();
$now = new \DateTime(); // CustomerTracking uses \DateTime, not \DateTimeImmutable
$tracking->setCustomer($customer);
$tracking->setCreateAT($now); // Use createAT
$tracking->setTrackId('track_id_123'); // Use trackId
$this->assertSame($customer, $tracking->getCustomer());
$this->assertSame($now, $tracking->getCreateAT());
$this->assertEquals('track_id_123', $tracking->getTrackId());
}
}

30
tests/Entity/DevisLineTest.php Normal file
View File

@@ -0,0 +1,30 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Devis;
use App\Entity\DevisLine;
use PHPUnit\Framework\TestCase;
class DevisLineTest extends TestCase
{
public function testGettersAndSetters()
{
$devisLine = new DevisLine();
$devis = new Devis();
$devisLine->setDevi($devis); // Use setDevi
$devisLine->setProduct('Product X'); // Use setProduct
$devisLine->setPos(1); // Use setPos
$devisLine->setPriceHt(50.0); // Use setPriceHt
$devisLine->setPriceHtSup(10.0); // Use setPriceHtSup
$devisLine->setDay(2); // Use setDay
$this->assertSame($devis, $devisLine->getDevi());
$this->assertEquals('Product X', $devisLine->getProduct());
$this->assertEquals(1, $devisLine->getPos());
$this->assertEquals(50.0, $devisLine->getPriceHt());
$this->assertEquals(10.0, $devisLine->getPriceHtSup());
$this->assertEquals(2, $devisLine->getDay());
}
}

26
tests/Entity/DevisOptionsTest.php Normal file
View File

@@ -0,0 +1,26 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Devis;
use App\Entity\DevisOptions;
use PHPUnit\Framework\TestCase;
class DevisOptionsTest extends TestCase
{
public function testGettersAndSetters()
{
$devisOption = new DevisOptions();
$devis = new Devis();
$devisOption->setDevis($devis);
$devisOption->setOption('Option A'); // Use setOption
$devisOption->setPriceHt(25.0); // Use setPriceHt
$devisOption->setDetails('Some details'); // Use setDetails
$this->assertSame($devis, $devisOption->getDevis());
$this->assertEquals('Option A', $devisOption->getOption());
$this->assertEquals(25.0, $devisOption->getPriceHt());
$this->assertEquals('Some details', $devisOption->getDetails());
}
}

90
tests/Entity/DevisTest.php Normal file
View File

@@ -0,0 +1,90 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Customer;
use App\Entity\CustomerAddress;
use App\Entity\Devis;
use App\Entity\DevisLine;
use App\Entity\DevisOptions;
use PHPUnit\Framework\TestCase;
class DevisTest extends TestCase
{
public function testGettersAndSetters()
{
$devis = new Devis();
$customer = new Customer();
$addressShip = new CustomerAddress();
$billAddress = new CustomerAddress();
$now = new \DateTimeImmutable();
$devis->setCustomer($customer);
$devis->setNum('DEVIS-001');
$devis->setCreateA($now);
$devis->setUpdateAt($now); // Use setUpdateAt
$devis->setState('pending');
$devis->setSignatureId('sign123');
$devis->setAddressShip($addressShip);
$devis->setBillAddress($billAddress);
$devis->setStartAt($now->modify('+1 day'));
$devis->setEndAt($now->modify('+2 days'));
$devis->setDevisFileName('devis.pdf');
$devis->setDevisFileSize(1024);
$devis->setDevisDocuSealFileName('docuseal.pdf');
$devis->setDevisDocuSealFileSize(2048);
$devis->setDevisSignedFileName('signed.pdf');
$devis->setDevisSignedFileSize(3072);
$devis->setDevisAuditFileName('audit.pdf');
$devis->setDevisAuditFileSize(4096);
$this->assertSame($customer, $devis->getCustomer());
$this->assertEquals('DEVIS-001', $devis->getNum());
$this->assertEquals($now, $devis->getCreateA());
$this->assertEquals($now, $devis->getUpdateAt()); // Use getUpdateAt
$this->assertEquals('pending', $devis->getState());
$this->assertEquals('sign123', $devis->getSignatureId());
$this->assertSame($addressShip, $devis->getAddressShip());
$this->assertSame($billAddress, $devis->getBillAddress());
$this->assertEquals($now->modify('+1 day'), $devis->getStartAt());
$this->assertEquals($now->modify('+2 days'), $devis->getEndAt());
$this->assertEquals('devis.pdf', $devis->getDevisFileName());
$this->assertEquals(1024, $devis->getDevisFileSize());
$this->assertEquals('docuseal.pdf', $devis->getDevisDocuSealFileName());
$this->assertEquals(2048, $devis->getDevisDocuSealFileSize());
$this->assertEquals('signed.pdf', $devis->getDevisSignedFileName());
$this->assertEquals(3072, $devis->getDevisSignedFileSize());
$this->assertEquals('audit.pdf', $devis->getDevisAuditFileName());
$this->assertEquals(4096, $devis->getDevisAuditFileSize());
}
public function testDevisLinesCollection()
{
$devis = new Devis();
$line = new DevisLine();
$this->assertCount(0, $devis->getDevisLines());
$devis->addDevisLine($line);
$this->assertCount(1, $devis->getDevisLines());
$this->assertSame($devis, $line->getDevi()); // Use getDevi
$devis->removeDevisLine($line);
$this->assertCount(0, $devis->getDevisLines());
$this->assertNull($line->getDevi()); // Use getDevi
}
public function testDevisOptionsCollection()
{
$devis = new Devis();
$option = new DevisOptions();
$this->assertCount(0, $devis->getDevisOptions());
$devis->addDevisOption($option);
$this->assertCount(1, $devis->getDevisOptions());
$this->assertSame($devis, $option->getDevis());
$devis->removeDevisOption($option);
$this->assertCount(0, $devis->getDevisOptions());
$this->assertNull($option->getDevis());
}
}

24
tests/Entity/EtatLieuxTest.php Normal file
View File

@@ -0,0 +1,24 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Contrats;
use App\Entity\EtatLieux;
use App\Entity\Prestaire;
use PHPUnit\Framework\TestCase;
class EtatLieuxTest extends TestCase
{
public function testGettersAndSetters()
{
$etatLieux = new EtatLieux();
$contrat = new Contrats();
$prestataire = new Prestaire();
$etatLieux->setContrat($contrat);
$etatLieux->setPrestataire($prestataire);
$this->assertSame($contrat, $etatLieux->getContrat());
$this->assertSame($prestataire, $etatLieux->getPrestataire());
}
}

27
tests/Entity/FactureTest.php Normal file
View File

@@ -0,0 +1,27 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Contrats;
use App\Entity\Facture;
use PHPUnit\Framework\TestCase;
class FactureTest extends TestCase
{
public function testGettersAndSetters()
{
$facture = new Facture();
$contrat = new Contrats();
$now = new \DateTimeImmutable();
$facture->setContrat($contrat);
$facture->setNum('INV-001');
$facture->setCreateAt($now);
$facture->setUpdateAt($now);
$this->assertSame($contrat, $facture->getContrat());
$this->assertEquals('INV-001', $facture->getNum());
$this->assertSame($now, $facture->getCreateAt());
$this->assertSame($now, $facture->getUpdateAt());
}
}

22
tests/Entity/FormulesOptionsInclusTest.php Normal file
View File

@@ -0,0 +1,22 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Formules;
use App\Entity\FormulesOptionsInclus;
use PHPUnit\Framework\TestCase;
class FormulesOptionsInclusTest extends TestCase
{
public function testGettersAndSetters()
{
$optionsInclus = new FormulesOptionsInclus();
$formule = new Formules();
$optionsInclus->setName('Included Option');
$optionsInclus->setFormule($formule);
$this->assertEquals('Included Option', $optionsInclus->getName());
$this->assertSame($formule, $optionsInclus->getFormule());
}
}

27
tests/Entity/FormulesProductInclusTest.php Normal file
View File

@@ -0,0 +1,27 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Formules;
use App\Entity\FormulesProductInclus;
use App\Entity\Product;
use PHPUnit\Framework\TestCase;
class FormulesProductInclusTest extends TestCase
{
public function testGettersAndSetters()
{
$productInclus = new FormulesProductInclus();
$formules = new Formules();
$product = new Product();
$config = ['key' => 'value'];
$productInclus->setFormules($formules);
$productInclus->setPRODUCT($product); // Note: setPRODUCT is uppercase in entity
$productInclus->setConfig($config);
$this->assertSame($formules, $productInclus->getFormules());
$this->assertSame($product, $productInclus->getPRODUCT());
$this->assertEquals($config, $productInclus->getConfig());
}
}

29
tests/Entity/FormulesRestrictionTest.php Normal file
View File

@@ -0,0 +1,29 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Formules;
use App\Entity\FormulesRestriction;
use PHPUnit\Framework\TestCase;
class FormulesRestrictionTest extends TestCase
{
public function testGettersAndSetters()
{
$restriction = new FormulesRestriction();
$formule = new Formules();
$config = ['min' => 1, 'max' => 5];
$restriction->setFormule($formule);
$restriction->setNbStructureMax(10);
$restriction->setRestrictionConfig($config);
$restriction->setNbAlimentaireMax(2);
$restriction->setNbBarhumsMax(3);
$this->assertSame($formule, $restriction->getFormule());
$this->assertEquals(10, $restriction->getNbStructureMax());
$this->assertEquals($config, $restriction->getRestrictionConfig());
$this->assertEquals(2, $restriction->getNbAlimentaireMax());
$this->assertEquals(3, $restriction->getNbBarhumsMax());
}
}

98
tests/Entity/FormulesTest.php Normal file
View File

@@ -0,0 +1,98 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Formules;
use App\Entity\FormulesOptionsInclus;
use App\Entity\FormulesProductInclus;
use App\Entity\FormulesRestriction;
use PHPUnit\Framework\TestCase;
class FormulesTest extends TestCase
{
public function testGettersAndSetters()
{
$formules = new Formules();
$now = new \DateTimeImmutable();
$formules->setName('Test Formule');
$formules->setImageName('image.jpg');
$formules->setImageSize(1024);
$formules->setUpdatedAt($now);
$formules->setType('package');
$formules->setIsPublish(true);
$formules->setDescription('Formule description');
$formules->setPrice1j(100.0);
$formules->setPrice2j(150.0);
$formules->setPrice5j(300.0);
$formules->setCaution(50.0);
$formules->setPos(1);
$this->assertEquals('Test Formule', $formules->getName());
$this->assertEquals('image.jpg', $formules->getImageName());
$this->assertEquals(1024, $formules->getImageSize());
$this->assertSame($now, $formules->getUpdatedAt());
$this->assertEquals('package', $formules->getType());
$this->assertTrue($formules->isPublish());
$this->assertEquals('Formule description', $formules->getDescription());
$this->assertEquals(100.0, $formules->getPrice1j());
$this->assertEquals(150.0, $formules->getPrice2j());
$this->assertEquals(300.0, $formules->getPrice5j());
$this->assertEquals(50.0, $formules->getCaution());
$this->assertEquals(1, $formules->getPos());
}
public function testSlug()
{
$formules = new Formules();
// $formules->setId(1); // ID is auto-generated, cannot be set directly in unit test
$formules->setName('Test Formule');
$this->assertEquals('-test-formule', $formules->slug()); // ID will be null
}
public function testFormulesProductInclusesCollection()
{
$formules = new Formules();
$productInclus = new FormulesProductInclus();
$this->assertCount(0, $formules->getFormulesProductIncluses());
$formules->addFormulesProductInclus($productInclus);
$this->assertCount(1, $formules->getFormulesProductIncluses());
$this->assertSame($formules, $productInclus->getFormules());
$formules->removeFormulesProductInclus($productInclus);
$this->assertCount(0, $formules->getFormulesProductIncluses());
$this->assertNull($productInclus->getFormules());
}
public function testFormulesOptionsInclusesCollection()
{
$formules = new Formules();
$optionInclus = new FormulesOptionsInclus();
$this->assertCount(0, $formules->getFormulesOptionsIncluses());
$formules->addFormulesOptionsInclus($optionInclus);
$this->assertCount(1, $formules->getFormulesOptionsIncluses());
$this->assertSame($formules, $optionInclus->getFormule());
$formules->removeFormulesOptionsInclus($optionInclus);
$this->assertCount(0, $formules->getFormulesOptionsIncluses());
$this->assertNull($optionInclus->getFormule());
}
public function testSetFormulesRestriction()
{
$formules = new Formules();
$restriction = new FormulesRestriction();
$this->assertNull($formules->getFormulesRestriction());
$formules->setFormulesRestriction($restriction);
$this->assertSame($restriction, $formules->getFormulesRestriction());
$this->assertSame($formules, $restriction->getFormule());
$formules->setFormulesRestriction(null);
$this->assertNull($formules->getFormulesRestriction());
$this->assertNull($restriction->getFormule());
}
}

41
tests/Entity/OptionsTest.php Normal file
View File

@@ -0,0 +1,41 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Options;
use Cocur\Slugify\Slugify; // Not needed for entity test
use PHPUnit\Framework\TestCase;
class OptionsTest extends TestCase
{
public function testGettersAndSetters()
{
$options = new Options();
$now = new \DateTimeImmutable();
$options->setName('Test Option');
$options->setPriceHt(25.0);
$options->setStripeId('opt_123');
$options->setImageName('option.jpg');
$options->setImageSize(512);
$options->setUpdatedAt($now);
$this->assertEquals('Test Option', $options->getName());
$this->assertEquals(25.0, $options->getPriceHt());
$this->assertEquals('opt_123', $options->getStripeId());
$this->assertEquals('option.jpg', $options->getImageName());
$this->assertEquals(512, $options->getImageSize());
$this->assertSame($now, $options->getUpdatedAt());
}
public function testSlug()
{
$options = new Options();
// ID is auto-generated, cannot be set directly in unit test
// For slug test, we will assume ID is null, or set it via reflection if absolutely needed.
// For simplicity, we will test the slug with a null ID.
$options->setName('Test Option');
$this->assertEquals('test-option', $options->slug());
}
}

60
tests/Entity/OrderSessionTest.php Normal file
View File

@@ -0,0 +1,60 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Customer;
use App\Entity\OrderSession;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Uid\Uuid;
class OrderSessionTest extends TestCase
{
public function testGettersAndSetters()
{
$session = new OrderSession();
$customer = new Customer();
$uuid = Uuid::v4();
$now = new \DateTimeImmutable();
$session->setUuid($uuid);
$session->setProducts(['prod1', 'prod2']);
$session->setCustomer($customer);
// createdAt is set in constructor and PrePersist callback, so no direct setter test
// updatedAt is set by PreUpdate callback, so no direct setter test
$session->setState('completed');
$session->setBillingAddress('123 Billing St');
$session->setBillingZipCode('54321');
$session->setBillingTown('Billingville');
$session->setAdressEvent('123 Event St');
$session->setAdress2Event('Apt 4B');
$session->setAdress3Event('Building C');
$session->setZipCodeEvent('98765');
$session->setTownEvent('Eventown');
$session->setType('personal');
$session->setDetails('Event details');
$session->setTypeSol('Hard');
$session->setPente('medium');
$session->setAccess('difficult');
$session->setDistancePower(25.5);
$this->assertEquals($uuid, $session->getUuid());
$this->assertEquals(['prod1', 'prod2'], $session->getProducts());
$this->assertSame($customer, $session->getCustomer());
$this->assertNotNull($session->getCreatedAt()); // Set by constructor
$this->assertEquals('completed', $session->getState());
$this->assertEquals('123 Billing St', $session->getBillingAddress());
$this->assertEquals('54321', $session->getBillingZipCode());
$this->assertEquals('Billingville', $session->getBillingTown());
$this->assertEquals('123 Event St', $session->getAdressEvent());
$this->assertEquals('Apt 4B', $session->getAdress2Event());
$this->assertEquals('Building C', $session->getAdress3Event());
$this->assertEquals('98765', $session->getZipCodeEvent());
$this->assertEquals('Eventown', $session->getTownEvent());
$this->assertEquals('personal', $session->getType());
$this->assertEquals('Event details', $session->getDetails());
$this->assertEquals('Hard', $session->getTypeSol());
$this->assertEquals('medium', $session->getPente());
$this->assertEquals('difficult', $session->getAccess());
$this->assertEquals(25.5, $session->getDistancePower());
}
}

50
tests/Entity/PrestaireTest.php Normal file
View File

@@ -0,0 +1,50 @@
<?php
namespace App\Tests\Entity;
use App\Entity\EtatLieux;
use App\Entity\Prestaire;
use PHPUnit\Framework\TestCase;
class PrestaireTest extends TestCase
{
public function testGettersAndSetters()
{
$prestaire = new Prestaire();
$prestaire->setEmail('prestaire@test.com');
$prestaire->setName('PrestaireName');
$prestaire->setSurname('PrestaireSurname');
$prestaire->setPhone('0123456789');
$prestaire->setRoles(['ROLE_PRESTAIRE']);
$this->assertEquals('prestaire@test.com', $prestaire->getEmail());
$this->assertEquals('PrestaireName', $prestaire->getName());
$this->assertEquals('PrestaireSurname', $prestaire->getSurname());
$this->assertEquals('0123456789', $prestaire->getPhone());
$this->assertContains('ROLE_PRESTAIRE', $prestaire->getRoles());
// $this->assertNull($prestaire->getPassword()); // As per entity's getPassword() TODO
$this->assertEquals('prestaire@test.com', $prestaire->getUserIdentifier());
}
public function testEtatLieuxesCollection()
{
$prestaire = new Prestaire();
$etatLieux = new EtatLieux();
$this->assertCount(0, $prestaire->getEtatLieuxes());
$prestaire->addEtatLieux($etatLieux);
$this->assertCount(1, $prestaire->getEtatLieuxes());
$this->assertSame($prestaire, $etatLieux->getPrestataire());
$prestaire->removeEtatLieux($etatLieux);
$this->assertCount(0, $prestaire->getEtatLieuxes());
$this->assertNull($etatLieux->getPrestataire());
}
public function testEraseCredentials()
{
$prestaire = new Prestaire();
$prestaire->eraseCredentials(); // Should do nothing as per entity's eraseCredentials() TODO
$this->assertTrue(true); // Just ensure it doesn't crash
}
}

48
tests/Entity/ProductDocTest.php Normal file
View File

@@ -0,0 +1,48 @@
<?php
namespace App\Tests\Entity;
use App\Entity\Product;
use App\Entity\ProductDoc;
use PHPUnit\Framework\TestCase;
class ProductDocTest extends TestCase
{
public function testGettersAndSetters()
{
$productDoc = new ProductDoc();
$product = new Product();
$now = new \DateTimeImmutable();
$productDoc->setProduct($product);
$productDoc->setName('Document 1');
$productDoc->setIsPublic(true);
$productDoc->setDocProductName('doc1.pdf');
$productDoc->setDocProductSize(1024);
$productDoc->setUpdatedAt($now);
$this->assertSame($product, $productDoc->getProduct());
$this->assertEquals('Document 1', $productDoc->getName());
$this->assertTrue($productDoc->isPublic());
$this->assertEquals('doc1.pdf', $productDoc->getDocProductName());
$this->assertEquals(1024, $productDoc->getDocProductSize());
$this->assertSame($now, $productDoc->getUpdatedAt());
}
public function testJson()
{
$product = new Product();
$product->setName('Main Product');
$productDoc = new ProductDoc();
$productDoc->setProduct($product);
$productDoc->setName('Doc Name');
$expectedJson = json_encode([
'name' => 'Doc Name',
'product' => 'Main Product',
]);
$this->assertEquals($expectedJson, $productDoc->json());
}
}

153
tests/Entity/ProductTest.php Normal file
View File

@@ -0,0 +1,153 @@
<?php
namespace App\Tests\Entity;
use App\Entity\FormulesProductInclus;
use App\Entity\Product;
use App\Entity\ProductDoc;
use App\Entity\ProductPhotos;
use App\Entity\ProductReserve;
use App\Entity\ProductVideo;
use PHPUnit\Framework\TestCase;
use Cocur\Slugify\Slugify; // To test the slug() method
class ProductTest extends TestCase
{
public function testGettersAndSetters()
{
$product = new Product();
$now = new \DateTimeImmutable();
$product->setRef('PROD-001');
$product->setCategory('Category A');
$product->setName('Test Product');
$product->setPriceDay(10.0);
$product->setPriceSup(5.0);
$product->setCaution(20.0);
$product->setImageName('product.jpg');
$product->setImageSize(1024);
$product->setUpdatedAt($now);
$product->setProductId('ext_prod_id');
$product->setDescription('Product description');
$product->setQt(5);
$product->setDimW(100.0);
$product->setDimH(50.0);
$product->setDimP(20.0);
$this->assertEquals('PROD-001', $product->getRef());
$this->assertEquals('Category A', $product->getCategory());
$this->assertEquals('Test Product', $product->getName());
$this->assertEquals(10.0, $product->getPriceDay());
$this->assertEquals(5.0, $product->getPriceSup());
$this->assertEquals(20.0, $product->getCaution());
$this->assertEquals('product.jpg', $product->getImageName());
$this->assertEquals(1024, $product->getImageSize());
$this->assertSame($now, $product->getUpdatedAt());
$this->assertEquals('ext_prod_id', $product->getProductId());
$this->assertEquals('Product description', $product->getDescription());
$this->assertEquals(5, $product->getQt());
$this->assertEquals(100.0, $product->getDimW());
$this->assertEquals(50.0, $product->getDimH());
$this->assertEquals(20.0, $product->getDimP());
}
public function testSlug()
{
$product = new Product();
// $product->setId(1); // ID is auto-generated, cannot be set directly in unit test
$product->setName('Awesome Product');
$this->assertEquals('awesome-product', $product->slug());
}
public function testJson()
{
$product = new Product();
// $product->setId(1); // ID is auto-generated
$product->setRef('PROD-JSON');
$product->setName('JSON Product');
$expectedJson = json_encode([
'id' => null, // ID is null for new entity
'ref' => 'PROD-JSON',
'name' => 'JSON Product',
]);
$this->assertEquals($expectedJson, $product->json());
}
public function testProductReservesCollection()
{
$product = new Product();
$reserve = new ProductReserve();
$this->assertCount(0, $product->getProductReserves());
$product->addProductReserf($reserve); // Typo: addProductReserf
$this->assertCount(1, $product->getProductReserves());
$this->assertSame($product, $reserve->getProduct());
$product->removeProductReserf($reserve); // Typo: removeProductReserf
$this->assertCount(0, $product->getProductReserves());
$this->assertNull($reserve->getProduct());
}
public function testProductDocsCollection()
{
$product = new Product();
$doc = new ProductDoc();
$this->assertCount(0, $product->getProductDocs());
$product->addProductDoc($doc);
$this->assertCount(1, $product->getProductDocs());
$this->assertSame($product, $doc->getProduct());
$product->removeProductDoc($doc);
$this->assertCount(0, $product->getProductDocs());
$this->assertNull($doc->getProduct());
}
public function testFormulesProductInclusesCollection()
{
$product = new Product();
$inclus = new FormulesProductInclus();
$this->assertCount(0, $product->getFormulesProductIncluses());
$product->addFormulesProductInclus($inclus);
$this->assertCount(1, $product->getFormulesProductIncluses());
$this->assertSame($product, $inclus->getPRODUCT());
$product->removeFormulesProductInclus($inclus);
$this->assertCount(0, $product->getFormulesProductIncluses());
$this->assertNull($inclus->getPRODUCT());
}
public function testProductPhotosCollection()
{
$product = new Product();
$photo = new ProductPhotos();
$this->assertCount(0, $product->getProductPhotos());
$product->addProductPhoto($photo);
$this->assertCount(1, $product->getProductPhotos());
$this->assertSame($product, $photo->getProduct());
$product->removeProductPhoto($photo);
$this->assertCount(0, $product->getProductPhotos());
$this->assertNull($photo->getProduct());
}
public function testProductVideosCollection()
{
$product = new Product();
$video = new ProductVideo();
$this->assertCount(0, $product->getProductVideos());
$product->addProductVideo($video);
$this->assertCount(1, $product->getProductVideos());
$this->assertSame($product, $video->getProduct());
$product->removeProductVideo($video);
$this->assertCount(0, $product->getProductVideos());
$this->assertNull($video->getProduct());
}
}

23
tests/Event/Object/EventAdminCreateTest.php Normal file
View File

@@ -0,0 +1,23 @@
<?php
namespace App\Tests\Event\Object;
use App\Entity\Account;
use App\Event\Object\EventAdminCreate;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
#[AllowMockObjectsWithoutExpectations]
class EventAdminCreateTest extends TestCase
{
public function testGetters()
{
$account = $this->createMock(Account::class);
$requestedAccount = $this->createMock(Account::class);
$event = new EventAdminCreate($account, $requestedAccount);
$this->assertSame($account, $event->getAccount());
$this->assertSame($requestedAccount, $event->getRequestedAccount());
}
}

23
tests/Event/Object/EventAdminDeletedTest.php Normal file
View File

@@ -0,0 +1,23 @@
<?php
namespace App\Tests\Event\Object;
use App\Entity\Account;
use App\Event\Object\EventAdminDeleted;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
#[AllowMockObjectsWithoutExpectations]
class EventAdminDeletedTest extends TestCase
{
public function testGetters()
{
$account = $this->createMock(Account::class);
$requestedAccount = $this->createMock(Account::class);
$event = new EventAdminDeleted($account, $requestedAccount);
$this->assertSame($account, $event->getAccount());
$this->assertSame($requestedAccount, $event->getRequestedAccount());
}
}

144
tests/Event/Service/AdminEventTest.php Normal file
View File

@@ -0,0 +1,144 @@
<?php
namespace App\Tests\Event\Service;
use App\Entity\Account;
use App\Entity\AccountResetPasswordRequest;
use App\Event\Object\EventAdminCreate;
use App\Event\Object\EventAdminDeleted;
use App\Event\Service\AdminEvent;
use App\Service\Mailer\Mailer;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
#[AllowMockObjectsWithoutExpectations]
class AdminEventTest extends TestCase
{
private $mailer;
private $urlGenerator;
private $entityManager;
private $adminEvent;
protected function setUp(): void
{
$this->mailer = $this->createMock(Mailer::class);
$this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->adminEvent = new AdminEvent(
$this->mailer,
$this->urlGenerator,
$this->entityManager
);
}
public function testOnAdminCreate()
{
$account = $this->createMock(Account::class);
$account->method('getId')->willReturn(1);
$account->method('getEmail')->willReturn('test@example.com');
$account->method('getFirstName')->willReturn('John');
$account->method('getName')->willReturn('Doe');
$requestedAccount = $this->createMock(Account::class);
$event = new EventAdminCreate($account, $requestedAccount);
$repo = $this->createMock(EntityRepository::class);
$this->entityManager->method('getRepository')->with(AccountResetPasswordRequest::class)->willReturn($repo);
$repo->method('findOneBy')->willReturn(null);
$this->entityManager->expects($this->once())->method('persist');
$this->entityManager->expects($this->once())->method('flush');
$this->urlGenerator->expects($this->once())
->method('generate')
->willReturn('http://example.com/reset');
$this->mailer->expects($this->once())
->method('send')
->with(
'test@example.com',
'John Doe',
'[Intranet Ludikevent] Activation de votre accès administrateur'
);
$this->adminEvent->onAdminCreate($event);
}
public function testOnAdminCreateExistingValidRequest()
{
$account = $this->createMock(Account::class);
$account->method('getId')->willReturn(1);
$account->method('getEmail')->willReturn('test@example.com');
$requestedAccount = $this->createMock(Account::class);
$event = new EventAdminCreate($account, $requestedAccount);
$existingRequest = new AccountResetPasswordRequest();
$existingRequest->setExpiresAt(new \DateTimeImmutable('+1 hour'));
$existingRequest->setToken('existing_token');
$repo = $this->createMock(EntityRepository::class);
$this->entityManager->method('getRepository')->with(AccountResetPasswordRequest::class)->willReturn($repo);
$repo->method('findOneBy')->willReturn($existingRequest);
// Should NOT persist a new one, but reuse existing
$this->entityManager->expects($this->never())->method('persist');
// Should generate URL with existing token
$this->urlGenerator->expects($this->once())
->method('generate')
->with(
'app_forgot_password_confirm',
['id' => 1, 'token' => 'existing_token']
);
$this->adminEvent->onAdminCreate($event);
}
public function testOnAdminCreateExistingExpiredRequest()
{
$account = $this->createMock(Account::class);
$account->method('getId')->willReturn(1);
$account->method('getEmail')->willReturn('test@example.com');
$requestedAccount = $this->createMock(Account::class);
$event = new EventAdminCreate($account, $requestedAccount);
$existingRequest = new AccountResetPasswordRequest();
$existingRequest->setExpiresAt(new \DateTimeImmutable('-1 hour'));
$repo = $this->createMock(EntityRepository::class);
$this->entityManager->method('getRepository')->with(AccountResetPasswordRequest::class)->willReturn($repo);
$repo->method('findOneBy')->willReturn($existingRequest);
// Should remove expired
$this->entityManager->expects($this->once())->method('remove')->with($existingRequest);
// Should persist new one
$this->entityManager->expects($this->atLeastOnce())->method('persist');
// Flush called for remove and persist
$this->entityManager->expects($this->atLeast(2))->method('flush');
$this->adminEvent->onAdminCreate($event);
}
public function testOnAdminDeleted()
{
$account = $this->createMock(Account::class);
$requestedAccount = $this->createMock(Account::class);
$event = new EventAdminDeleted($account, $requestedAccount);
$this->mailer->expects($this->exactly(2))
->method('send')
->with(
$this->stringContains('@'), // Simple check for email arg
$this->stringContains('Notification'),
"[Intranet Ludikevent] - Suppression d'un administrateur"
);
$this->adminEvent->onAdminDeleted($event);
}
}

62
tests/Event/Service/LoginStatsSubscriberTest.php Normal file
View File

@@ -0,0 +1,62 @@
<?php
namespace App\Tests\Event\Service;
use App\Entity\Account;
use App\Entity\AccountLoginRegister;
use App\Event\Service\LoginStatsSubscriber;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Http\Event\LoginSuccessEvent;
#[AllowMockObjectsWithoutExpectations]
class LoginStatsSubscriberTest extends TestCase
{
private $entityManager;
private $subscriber;
protected function setUp(): void
{
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->subscriber = new LoginStatsSubscriber($this->entityManager);
}
public function testOnLoginSuccessWithAccount()
{
$user = $this->createMock(Account::class);
$request = new Request([], [], [], [], [], ['REMOTE_ADDR' => '127.0.0.1']);
$request->headers->set('User-Agent', 'TestAgent');
// Manually setting client IP on Request is tricky without relying on 'REMOTE_ADDR' server var or trusted proxies
// But getClientIp() defaults to null or 127.0.0.1 depending on setup.
// We can just rely on the default behavior for this test or mock the request if it was an interface/mockable.
// Since Request is a concrete class, we use it as is.
$event = $this->createMock(LoginSuccessEvent::class);
$event->method('getUser')->willReturn($user);
$event->method('getRequest')->willReturn($request);
$this->entityManager->expects($this->once())
->method('persist')
->with($this->isInstanceOf(AccountLoginRegister::class));
$this->entityManager->expects($this->once())->method('flush');
$this->subscriber->onLoginSuccess($event);
}
public function testOnLoginSuccessWithNonAccountUser()
{
$user = $this->createMock(UserInterface::class);
$event = $this->createMock(LoginSuccessEvent::class);
$event->method('getUser')->willReturn($user);
$this->entityManager->expects($this->never())->method('persist');
$this->entityManager->expects($this->never())->method('flush');
$this->subscriber->onLoginSuccess($event);
}
}

20
tests/Event/Signature/ContratEventTest.php Normal file
View File

@@ -0,0 +1,20 @@
<?php
namespace App\Tests\Event\Signature;
use App\Entity\Contrats;
use App\Event\Signature\ContratEvent;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
#[AllowMockObjectsWithoutExpectations]
class ContratEventTest extends TestCase
{
public function testGetContrats()
{
$contrats = $this->createMock(Contrats::class);
$event = new ContratEvent($contrats);
$this->assertSame($contrats, $event->getContrats());
}
}

135
tests/Event/Signature/ContratSubscriberTest.php Normal file
View File

@@ -0,0 +1,135 @@
<?php
namespace App\Tests\Event\Signature;
use App\Entity\Contrats;
use App\Entity\Customer;
use App\Event\Signature\ContratEvent;
use App\Event\Signature\ContratSubscriber;
use App\Service\Mailer\Mailer;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpKernel\KernelInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Vich\UploaderBundle\Storage\StorageInterface;
use Vich\UploaderBundle\Templating\Helper\UploaderHelper;
#[AllowMockObjectsWithoutExpectations]
class ContratSubscriberTest extends TestCase
{
private $mailer;
private $urlGenerator;
private $kernel;
private $uploaderHelper;
private $storage;
private $subscriber;
private $tempDir;
protected function setUp(): void
{
$this->mailer = $this->createMock(Mailer::class);
$this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$this->kernel = $this->createMock(KernelInterface::class);
$this->storage = $this->createMock(StorageInterface::class);
$this->uploaderHelper = new UploaderHelper($this->storage); // Real class as it's final
$this->tempDir = sys_get_temp_dir() . '/contrat_test_' . uniqid();
mkdir($this->tempDir . '/public', 0777, true);
$this->subscriber = new ContratSubscriber(
$this->mailer,
$this->urlGenerator,
$this->kernel,
$this->uploaderHelper
);
$_ENV['CONTRAT_BASEURL'] = 'https://baseurl.com';
}
protected function tearDown(): void
{
$this->removeDirectory($this->tempDir);
}
public function testOnContratSendWithAttachment()
{
// 1. Setup File
$relativePath = '/uploads/contrats/c1.pdf';
mkdir(dirname($this->tempDir . '/public' . $relativePath), 0777, true);
file_put_contents($this->tempDir . '/public' . $relativePath, 'PDF Content');
$this->kernel->method('getProjectDir')->willReturn($this->tempDir);
// 2. Setup Entities
$customer = $this->createMock(Customer::class);
$customer->method('getEmail')->willReturn('cust@test.com');
$customer->method('getSurname')->willReturn('John');
$customer->method('getName')->willReturn('Doe');
$contrat = $this->createMock(Contrats::class);
$contrat->method('getCustomer')->willReturn($customer);
$contrat->method('getNumReservation')->willReturn('RES-123');
$this->storage->method('resolveUri')->willReturn($relativePath);
$event = new ContratEvent($contrat);
// 3. Expectations
$this->urlGenerator->expects($this->once())
->method('generate')
->with('gestion_contrat_view', ['num' => 'RES-123']);
$this->mailer->expects($this->once())
->method('send')
->with(
'cust@test.com',
'John Doe',
'[Ludikevent] - Contrat de location N°RES-123',
'mails/sign/contrat.twig',
$this->anything(),
$this->callback(function($attachments) {
return count($attachments) === 1;
})
);
$this->subscriber->onContratSend($event);
}
public function testOnContratSendWithoutAttachment()
{
// No file created
$this->kernel->method('getProjectDir')->willReturn($this->tempDir);
$customer = $this->createMock(Customer::class);
$customer->method('getEmail')->willReturn('cust@test.com'); // Mock email
$contrat = $this->createMock(Contrats::class);
$contrat->method('getCustomer')->willReturn($customer);
$contrat->method('getNumReservation')->willReturn('RES-123');
$this->storage->method('resolveUri')->willReturn(null);
$event = new ContratEvent($contrat);
$this->mailer->expects($this->once())
->method('send')
->with(
$this->anything(),
$this->anything(),
$this->anything(),
$this->anything(),
$this->anything(),
[] // Empty attachments
);
$this->subscriber->onContratSend($event);
}
private function removeDirectory($dir) {
if (!is_dir($dir)) return;
$files = array_diff(scandir($dir), array('.','..'));
foreach ($files as $file) {
(is_dir("$dir/$file")) ? $this->removeDirectory("$dir/$file") : unlink("$dir/$file");
}
rmdir($dir);
}
}

20
tests/Event/Signature/DevisSendTest.php Normal file
View File

@@ -0,0 +1,20 @@
<?php
namespace App\Tests\Event\Signature;
use App\Entity\Devis;
use App\Event\Signature\DevisSend;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
#[AllowMockObjectsWithoutExpectations]
class DevisSendTest extends TestCase
{
public function testGetDevis()
{
$devis = $this->createMock(Devis::class);
$event = new DevisSend($devis);
$this->assertSame($devis, $event->getDevis());
}
}

68
tests/Event/Signature/DevisSubscriberTest.php Normal file
View File

@@ -0,0 +1,68 @@
<?php
namespace App\Tests\Event\Signature;
use App\Entity\Customer;
use App\Entity\Devis;
use App\Event\Signature\DevisSend;
use App\Event\Signature\DevisSubscriber;
use App\Service\Mailer\Mailer;
use App\Service\Signature\Client;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
#[AllowMockObjectsWithoutExpectations]
class DevisSubscriberTest extends TestCase
{
private $entityManager;
private $mailer;
private $client;
private $subscriber;
protected function setUp(): void
{
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->mailer = $this->createMock(Mailer::class);
$this->client = $this->createMock(Client::class);
$this->subscriber = new DevisSubscriber(
$this->entityManager,
$this->mailer,
$this->client
);
}
public function testOnDevisSend()
{
$customer = $this->createMock(Customer::class);
$customer->method('getEmail')->willReturn('cust@test.com');
$customer->method('getName')->willReturn('Doe');
$customer->method('getSurname')->willReturn('John');
$devis = $this->createMock(Devis::class);
$devis->method('getCustomer')->willReturn($customer);
$devis->method('getSignatureId')->willReturn('sign_id_123');
$event = new DevisSend($devis);
$this->client->expects($this->once())
->method('getLinkSign')
->with('sign_id_123')
->willReturn('http://sign.link');
$this->mailer->expects($this->once())
->method('send')
->with(
'cust@test.com',
'Doe John',
'[Signature Ludikevent] - Signature de votre devis pour votre location',
'mails/sign/devis.twig',
$this->callback(function($context) use ($devis) {
return $context['devis'] === $devis && $context['signLink'] === 'http://sign.link';
})
);
$this->subscriber->onDevisSend($event);
}
}

84
tests/Logger/AppLoggerTest.php Normal file
View File

@@ -0,0 +1,84 @@
<?php
namespace App\Tests\Logger;
use App\Entity\Account;
use App\Entity\AuditLog;
use App\Logger\AppLogger;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\Security\Core\User\UserInterface;
#[AllowMockObjectsWithoutExpectations]
class AppLoggerTest extends TestCase
{
private $entityManager;
private $security;
private $requestStack;
private $logger;
protected function setUp(): void
{
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->security = $this->createMock(Security::class);
$this->requestStack = $this->createMock(RequestStack::class);
$this->logger = new AppLogger(
$this->entityManager,
$this->security,
$this->requestStack
);
}
public function testRecordWithAccountUser()
{
$user = $this->createMock(Account::class);
$this->security->method('getUser')->willReturn($user);
$request = new Request();
$request->headers->set('User-Agent', 'TestAgent');
$this->requestStack->method('getCurrentRequest')->willReturn($request);
$this->entityManager->expects($this->once())
->method('persist')
->with($this->isInstanceOf(AuditLog::class));
$this->entityManager->expects($this->once())->method('flush');
$this->logger->record('TEST_TYPE', 'Test Message');
}
public function testRecordWithNonAccountUser()
{
$user = $this->createMock(UserInterface::class);
$this->security->method('getUser')->willReturn($user);
$this->entityManager->expects($this->never())->method('persist');
$this->entityManager->expects($this->never())->method('flush');
$this->logger->record('TEST_TYPE', 'Test Message');
}
public function testRecordWithNoRequest()
{
$user = $this->createMock(Account::class);
$this->security->method('getUser')->willReturn($user);
$this->requestStack->method('getCurrentRequest')->willReturn(null);
$this->entityManager->expects($this->once())
->method('persist')
->with($this->callback(function(AuditLog $log) {
return $log->getPath() === 'CLI/Internal';
}));
$this->entityManager->expects($this->once())->method('flush');
$this->logger->record('TEST_TYPE', 'Test Message');
}
}

106
tests/Repository/AccountRepositoryTest.php Normal file
View File

@@ -0,0 +1,106 @@
<?php
namespace App\Tests\Repository;
use App\Entity\Account;
use App\Repository\AccountRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Symfony\Component\Uid\Uuid;
class AccountRepositoryTest extends KernelTestCase
{
private ?EntityManagerInterface $entityManager;
private ?AccountRepository $repository;
protected function setUp(): void
{
$kernel = self::bootKernel();
$this->entityManager = $kernel->getContainer()
->get('doctrine')
->getManager();
$this->repository = $this->entityManager->getRepository(Account::class);
}
protected function tearDown(): void
{
parent::tearDown();
$this->entityManager->close();
$this->entityManager = null;
$this->repository = null;
}
public function testFindAdmin()
{
// 1. Create Admins
$admin = new Account();
$admin->setEmail('admin_' . uniqid() . '@test.com');
$admin->setRoles(['ROLE_ADMIN']);
$admin->setPassword('password');
$admin->setName('Admin');
$admin->setFirstName('User');
$admin->setUsername('admin_user_' . uniqid());
$admin->setUuid(Uuid::v4());
$admin->setIsActif(true);
$admin->setIsFirstLogin(false);
$this->entityManager->persist($admin);
// 2. Create Non-Admin
$user = new Account();
$user->setEmail('user_' . uniqid() . '@test.com');
$user->setRoles(['ROLE_USER']);
$user->setPassword('password');
$user->setName('User');
$user->setFirstName('Normal');
$user->setUsername('normal_user_' . uniqid());
$user->setUuid(Uuid::v4());
$user->setIsActif(true);
$user->setIsFirstLogin(false);
$this->entityManager->persist($user);
$this->entityManager->flush();
// 3. Test findAdmin
$admins = $this->repository->findAdmin();
$this->assertGreaterThanOrEqual(1, count($admins));
$found = false;
foreach ($admins as $a) {
if ($a->getEmail() === 'admin@test.com') {
$found = true;
}
// Ensure no user is returned (this might be tricky if other tests persist data,
// but we check if our non-admin is in the list)
if ($a->getEmail() === 'user@test.com') {
$this->fail('Non-admin user returned in findAdmin()');
}
}
$this->assertTrue($found, 'Admin user not found in findAdmin() result');
}
public function testUpgradePassword()
{
$user = new Account();
$user->setEmail('upgrade_' . uniqid() . '@test.com');
$user->setRoles(['ROLE_USER']);
$user->setPassword('old_hash');
$user->setName('Upgrade');
$user->setFirstName('User');
$user->setUsername('upgrade_user_' . uniqid());
$user->setUuid(Uuid::v4());
$user->setIsActif(true);
$user->setIsFirstLogin(false);
$this->entityManager->persist($user);
$this->entityManager->flush();
$this->repository->upgradePassword($user, 'new_encoded_password');
$updatedUser = $this->repository->find($user->getId());
$this->assertEquals('new_encoded_password', $updatedUser->getPassword());
}
}

117
tests/Repository/ContratsRepositoryTest.php Normal file
View File

@@ -0,0 +1,117 @@
<?php
namespace App\Tests\Repository;
use App\Entity\Contrats;
use App\Entity\Customer;
use App\Repository\ContratsRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
class ContratsRepositoryTest extends KernelTestCase
{
private ?EntityManagerInterface $entityManager;
private ?ContratsRepository $repository;
protected function setUp(): void
{
$kernel = self::bootKernel();
$this->entityManager = $kernel->getContainer()
->get('doctrine')
->getManager();
$this->repository = $this->entityManager->getRepository(Contrats::class);
}
protected function tearDown(): void
{
parent::tearDown();
$this->entityManager->close();
$this->entityManager = null;
$this->repository = null;
}
public function testFindBetweenDates()
{
$customer = new Customer();
$customer->setEmail('contrat_' . uniqid() . '@test.com');
$customer->setName('Test');
$customer->setSurname('Contrat');
$customer->setPhone('0600000000');
$customer->setCiv('Mr');
$customer->setType('pro');
$this->entityManager->persist($customer);
// 1. Create Contrats
// Target: 2026-06-15
$contratTarget = new Contrats();
$contratTarget->setDateAt(new \DateTimeImmutable('2026-06-15 12:00:00'));
$contratTarget->setEndAt(new \DateTimeImmutable('2026-06-16 12:00:00'));
$contratTarget->setCreateAt(new \DateTimeImmutable());
$contratTarget->setNumReservation('RES-TARGET');
$contratTarget->setAddressEvent('123 Main St');
$contratTarget->setZipCodeEvent('12345');
$contratTarget->setTownEvent('City');
$contratTarget->setType('event');
$contratTarget->setPente('flat');
$contratTarget->setIsSigned(false);
$contratTarget->setCustomer($customer);
$this->entityManager->persist($contratTarget);
// Before: 2026-06-01
$contratBefore = new Contrats();
$contratBefore->setDateAt(new \DateTimeImmutable('2026-06-01 12:00:00'));
$contratBefore->setEndAt(new \DateTimeImmutable('2026-06-02 12:00:00'));
$contratBefore->setCreateAt(new \DateTimeImmutable());
$contratBefore->setNumReservation('RES-BEFORE');
$contratBefore->setAddressEvent('123 Main St');
$contratBefore->setZipCodeEvent('12345');
$contratBefore->setTownEvent('City');
$contratBefore->setType('event');
$contratBefore->setPente('flat');
$contratBefore->setIsSigned(false);
$contratBefore->setCustomer($customer);
$this->entityManager->persist($contratBefore);
// After: 2026-07-01
$contratAfter = new Contrats();
$contratAfter->setDateAt(new \DateTimeImmutable('2026-07-01 12:00:00'));
$contratAfter->setEndAt(new \DateTimeImmutable('2026-07-02 12:00:00'));
$contratAfter->setCreateAt(new \DateTimeImmutable());
$contratAfter->setNumReservation('RES-AFTER');
$contratAfter->setAddressEvent('123 Main St');
$contratAfter->setZipCodeEvent('12345');
$contratAfter->setTownEvent('City');
$contratAfter->setType('event');
$contratAfter->setPente('flat');
$contratAfter->setIsSigned(false);
$contratAfter->setCustomer($customer);
$this->entityManager->persist($contratAfter);
$this->entityManager->flush();
// 2. Search Interval: 2026-06-10 to 2026-06-20
$start = new \DateTimeImmutable('2026-06-10 00:00:00');
$end = new \DateTimeImmutable('2026-06-20 00:00:00');
$results = $this->repository->findBetweenDates($start, $end);
$this->assertGreaterThanOrEqual(1, count($results));
$foundTarget = false;
foreach ($results as $contrat) {
if ($contrat->getNumReservation() === 'RES-TARGET') {
$foundTarget = true;
}
if ($contrat->getNumReservation() === 'RES-BEFORE') {
$this->fail('Contrat BEFORE interval should not be found');
}
if ($contrat->getNumReservation() === 'RES-AFTER') {
$this->fail('Contrat AFTER interval should not be found');
}
}
$this->assertTrue($foundTarget, 'Target contrat not found');
}
}

68
tests/Security/AccessDeniedHandlerTest.php Normal file
View File

@@ -0,0 +1,68 @@
<?php
namespace App\Tests\Security;
use App\Security\AccessDeniedHandler;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Twig\Environment;
#[AllowMockObjectsWithoutExpectations]
class AccessDeniedHandlerTest extends TestCase
{
private $urlGenerator;
private $twig;
private $handler;
protected function setUp(): void
{
$this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$this->twig = $this->createMock(Environment::class);
$this->handler = new AccessDeniedHandler($this->urlGenerator, $this->twig);
}
public function testHandleAdminPathRedirectsToHome()
{
$request = Request::create('/admin/dashboard');
$exception = new AccessDeniedException();
$this->urlGenerator->expects($this->once())
->method('generate')
->with('app_home')
->willReturn('/home');
$response = $this->handler->handle($request, $exception);
$this->assertInstanceOf(RedirectResponse::class, $response);
$this->assertEquals('/home', $response->getTargetUrl());
}
public function testHandleJsonRequestReturnsForbidden()
{
$request = Request::create('/api/data');
$request->headers->set('Accept', 'application/json');
$exception = new AccessDeniedException();
$response = $this->handler->handle($request, $exception);
$this->assertInstanceOf(JsonResponse::class, $response);
$this->assertEquals(Response::HTTP_FORBIDDEN, $response->getStatusCode());
}
public function testHandleDefaultReturnsForbidden()
{
$request = Request::create('/some/other/path');
$exception = new AccessDeniedException();
$response = $this->handler->handle($request, $exception);
$this->assertInstanceOf(JsonResponse::class, $response);
$this->assertEquals(Response::HTTP_FORBIDDEN, $response->getStatusCode());
}
}

119
tests/Security/AuthenticationEntryPointTest.php Normal file
View File

@@ -0,0 +1,119 @@
<?php
namespace App\Tests\Security;
use App\Entity\Account;
use App\Entity\Customer;
use App\Security\AuthenticationEntryPoint;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
#[AllowMockObjectsWithoutExpectations]
class AuthenticationEntryPointTest extends TestCase
{
private $urlGenerator;
private $tokenStorage;
private $entryPoint;
protected function setUp(): void
{
$this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$this->tokenStorage = $this->createMock(TokenStorageInterface::class);
$this->entryPoint = new AuthenticationEntryPoint($this->urlGenerator, $this->tokenStorage);
}
public function testStartJsonRequestReturnsForbidden()
{
$request = Request::create('/api/resource');
$request->headers->set('Accept', 'application/json');
$response = $this->entryPoint->start($request);
$this->assertInstanceOf(JsonResponse::class, $response);
$this->assertEquals(Response::HTTP_FORBIDDEN, $response->getStatusCode());
}
public function testStartCrmPathWithCustomerRedirectsToHome()
{
$request = Request::create('/crm/dashboard');
$customer = $this->createMock(Customer::class);
$token = $this->createMock(TokenInterface::class);
$token->method('getUser')->willReturn($customer);
$this->tokenStorage->method('getToken')->willReturn($token);
$this->urlGenerator->expects($this->once())
->method('generate')
->with('app_home')
->willReturn('/home');
$response = $this->entryPoint->start($request);
$this->assertInstanceOf(RedirectResponse::class, $response);
$this->assertEquals('/home', $response->getTargetUrl());
}
public function testStartCrmPathWithoutUserRedirectsToHome()
{
$request = Request::create('/crm/dashboard');
$this->tokenStorage->method('getToken')->willReturn(null);
$this->urlGenerator->expects($this->once())
->method('generate')
->with('app_home')
->willReturn('/home');
$response = $this->entryPoint->start($request);
$this->assertInstanceOf(RedirectResponse::class, $response);
$this->assertEquals('/home', $response->getTargetUrl());
}
public function testStartReservationPathWithoutUserRedirectsToReservationLogin()
{
$request = Request::create('/reservation/book');
$this->tokenStorage->method('getToken')->willReturn(null);
$this->urlGenerator->expects($this->once())
->method('generate')
->with('reservation_login')
->willReturn('/reservation/login');
$response = $this->entryPoint->start($request);
$this->assertInstanceOf(RedirectResponse::class, $response);
$this->assertEquals('/reservation/login', $response->getTargetUrl());
}
public function testStartReservationPathWithUserRedirectsToHomeOnlyBecauseDefaultFallback()
{
// Note: The logic in AuthenticationEntryPoint for /reservation only handles !$user.
// If user exists (Account or Customer), it falls through to the default return at the end.
$request = Request::create('/reservation/book');
$user = $this->createMock(Account::class);
$token = $this->createMock(TokenInterface::class);
$token->method('getUser')->willReturn($user);
$this->tokenStorage->method('getToken')->willReturn($token);
$this->urlGenerator->expects($this->once())
->method('generate')
->with('app_home')
->willReturn('/home');
$response = $this->entryPoint->start($request);
$this->assertInstanceOf(RedirectResponse::class, $response);
$this->assertEquals('/home', $response->getTargetUrl());
}
}

86
tests/Security/CustomerAuthenticatorTest.php Normal file
View File

@@ -0,0 +1,86 @@
<?php
namespace App\Tests\Security;
use App\Entity\Customer;
use App\Security\CustomerAuthenticator;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\CsrfTokenBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
#[AllowMockObjectsWithoutExpectations]
class CustomerAuthenticatorTest extends TestCase
{
private $urlGenerator;
private $entityManager;
private $authenticator;
protected function setUp(): void
{
$this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->authenticator = new CustomerAuthenticator($this->urlGenerator, $this->entityManager);
}
public function testSupports()
{
$request = Request::create('/reservation/login', 'POST');
$request->attributes->set('_route', 'reservation_login');
$this->assertTrue($this->authenticator->supports($request));
$requestInvalid = Request::create('/reservation/login', 'GET');
$requestInvalid->attributes->set('_route', 'reservation_login');
$this->assertFalse($this->authenticator->supports($requestInvalid));
}
public function testAuthenticate()
{
$request = Request::create('/login', 'POST', [
'_username' => 'test@test.com',
'_password' => 'password',
'_csrf_token' => 'token'
]);
$session = $this->createMock(SessionInterface::class);
$request->setSession($session);
$repository = $this->createMock(EntityRepository::class);
$this->entityManager->method('getRepository')->with(Customer::class)->willReturn($repository);
$repository->method('findOneBy')->with(['email' => 'test@test.com'])->willReturn(new Customer());
$passport = $this->authenticator->authenticate($request);
$this->assertInstanceOf(Passport::class, $passport);
$this->assertTrue($passport->hasBadge(UserBadge::class));
$this->assertTrue($passport->hasBadge(CsrfTokenBadge::class));
}
public function testOnAuthenticationSuccessRedirectsToReservation()
{
$request = Request::create('/login');
$session = $this->createMock(SessionInterface::class);
$request->setSession($session);
$token = $this->createMock(TokenInterface::class);
$this->urlGenerator->expects($this->once())
->method('generate')
->with('reservation')
->willReturn('/reservation');
$response = $this->authenticator->onAuthenticationSuccess($request, $token, 'main');
$this->assertInstanceOf(RedirectResponse::class, $response);
$this->assertEquals('/reservation', $response->getTargetUrl());
}
}

88
tests/Security/ErrorListenerTest.php Normal file
View File

@@ -0,0 +1,88 @@
<?php
namespace App\Tests\Security;
use App\Security\ErrorListener;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\ExceptionEvent;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Twig\Environment;
#[AllowMockObjectsWithoutExpectations]
class ErrorListenerTest extends TestCase
{
private $twig;
private $listener;
protected function setUp(): void
{
$this->twig = $this->createMock(Environment::class);
$this->listener = new ErrorListener($this->twig);
}
public function testOnKernelExceptionInDevModeDoesNothing()
{
$_ENV['APP_ENV'] = 'dev';
$kernel = $this->createMock(HttpKernelInterface::class);
$request = new Request();
$event = new ExceptionEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST, new \Exception());
$this->listener->onKernelException($event);
$this->assertNull($event->getResponse());
unset($_ENV['APP_ENV']); // Cleanup
}
public function testOnKernelExceptionJsonRequest()
{
$_ENV['APP_ENV'] = 'prod';
$kernel = $this->createMock(HttpKernelInterface::class);
$request = new Request();
$request->headers->set('Accept', 'application/json');
$exception = new NotFoundHttpException('Not found');
$event = new ExceptionEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST, $exception);
$this->listener->onKernelException($event);
$response = $event->getResponse();
$this->assertInstanceOf(JsonResponse::class, $response);
$this->assertEquals(404, $response->getStatusCode());
$content = json_decode($response->getContent(), true);
$this->assertEquals('error', $content['status']);
$this->assertEquals('Resource not found', $content['message']);
unset($_ENV['APP_ENV']);
}
public function testOnKernelExceptionHtmlRequest()
{
$_ENV['APP_ENV'] = 'prod';
$kernel = $this->createMock(HttpKernelInterface::class);
$request = new Request();
$exception = new \Exception('Error');
$event = new ExceptionEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST, $exception);
$this->twig->expects($this->once())
->method('render')
->with('error/500.twig', $this->anything())
->willReturn('<html>Error</html>');
$this->listener->onKernelException($event);
$response = $event->getResponse();
$this->assertInstanceOf(Response::class, $response);
$this->assertEquals(500, $response->getStatusCode());
$this->assertEquals('<html>Error</html>', $response->getContent());
unset($_ENV['APP_ENV']);
}
}

92
tests/Security/FlowAuthenticatorTest.php Normal file
View File

@@ -0,0 +1,92 @@
<?php
namespace App\Tests\Security;
use App\Entity\Customer;
use App\Entity\OrderSession;
use App\Security\FlowAuthenticator;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\CsrfTokenBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
#[AllowMockObjectsWithoutExpectations]
class FlowAuthenticatorTest extends TestCase
{
private $urlGenerator;
private $entityManager;
private $authenticator;
protected function setUp(): void
{
$this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->authenticator = new FlowAuthenticator($this->urlGenerator, $this->entityManager);
}
public function testSupports()
{
$request = Request::create('/reservation/flow', 'POST');
$request->attributes->set('_route', 'reservation_flow');
$this->assertTrue($this->authenticator->supports($request));
}
public function testAuthenticate()
{
$request = Request::create('/reservation/flow', 'POST', [
'_username' => 'test@test.com',
'_password' => 'password',
'_csrf_token' => 'token'
]);
$session = $this->createMock(SessionInterface::class);
$request->setSession($session);
$repository = $this->createMock(EntityRepository::class);
$this->entityManager->method('getRepository')->with(Customer::class)->willReturn($repository);
$repository->method('findOneBy')->with(['email' => 'test@test.com'])->willReturn(new Customer());
$passport = $this->authenticator->authenticate($request);
$this->assertInstanceOf(Passport::class, $passport);
$this->assertTrue($passport->hasBadge(UserBadge::class));
}
public function testOnAuthenticationSuccess()
{
$request = Request::create('/reservation/flow');
$request->attributes->set('sessionId', 'session-123');
$token = $this->createMock(TokenInterface::class);
$customer = new Customer();
$token->method('getUser')->willReturn($customer);
$sessionRepo = $this->createMock(EntityRepository::class);
$orderSession = $this->createMock(OrderSession::class);
$this->entityManager->method('getRepository')->with(OrderSession::class)->willReturn($sessionRepo);
$sessionRepo->method('findOneBy')->with(['uuid' => 'session-123'])->willReturn($orderSession);
$orderSession->expects($this->once())->method('setCustomer')->with($customer);
$this->entityManager->expects($this->once())->method('flush');
$this->urlGenerator->expects($this->once())
->method('generate')
->with('reservation_flow', ['sessionId' => 'session-123'])
->willReturn('/reservation/flow/session-123');
$response = $this->authenticator->onAuthenticationSuccess($request, $token, 'main');
$this->assertInstanceOf(RedirectResponse::class, $response);
$this->assertEquals('/reservation/flow/session-123', $response->getTargetUrl());
}
}

95
tests/Security/IntranetLockedTest.php Normal file
View File

@@ -0,0 +1,95 @@
<?php
namespace App\Tests\Security;
use App\Security\IntranetLocked;
use App\Service\Mailer\Mailer;
use App\Service\Signature\Client as SignatureClient;
use App\Service\Search\Client as SearchClient;
use App\Service\Stripe\Client as StripeClient;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Symfony\Component\HttpFoundation\Request;
use Twig\Environment;
#[AllowMockObjectsWithoutExpectations]
class IntranetLockedTest extends TestCase
{
private $twig;
private $signatureClient;
private $searchClient;
private $stripeClient;
private $mailer;
private $listener;
protected function setUp(): void
{
$this->twig = $this->createMock(Environment::class);
$this->signatureClient = $this->createMock(SignatureClient::class);
$this->searchClient = $this->createMock(SearchClient::class);
$this->stripeClient = $this->createMock(StripeClient::class);
$this->mailer = $this->createMock(Mailer::class);
$this->listener = new IntranetLocked(
$this->twig,
$this->signatureClient,
$this->searchClient,
$this->stripeClient,
$this->mailer
);
}
public function testOnLockedWhenEnabled()
{
$_ENV['INTRANET_LOCK'] = 'true';
$kernel = $this->createMock(HttpKernelInterface::class);
$request = new Request();
$event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
$this->twig->expects($this->once())->method('render')->with('security/locked.twig')->willReturn('Locked');
$this->listener->onLocked($event);
$response = $event->getResponse();
$this->assertInstanceOf(Response::class, $response);
$this->assertEquals(Response::HTTP_FORBIDDEN, $response->getStatusCode());
unset($_ENV['INTRANET_LOCK']);
}
public function testOnControlAllServicesUp()
{
$kernel = $this->createMock(HttpKernelInterface::class);
$request = new Request();
$event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
$this->signatureClient->method('status')->willReturn(true);
$this->searchClient->method('status')->willReturn(true);
$this->stripeClient->method('status')->willReturn(true);
$this->listener->onControl($event);
$this->assertNull($event->getResponse());
}
public function testOnControlServiceDown()
{
$kernel = $this->createMock(HttpKernelInterface::class);
$request = new Request();
$event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
$this->signatureClient->method('status')->willReturn(false);
$this->mailer->expects($this->once())->method('send');
$this->twig->expects($this->once())->method('render')->with('security/error.twig')->willReturn('Error');
$this->listener->onControl($event);
$response = $event->getResponse();
$this->assertInstanceOf(Response::class, $response);
$this->assertEquals(Response::HTTP_FORBIDDEN, $response->getStatusCode());
}
}

86
tests/Security/KeycloakAuthenticatorTest.php Normal file
View File

@@ -0,0 +1,86 @@
<?php
namespace App\Tests\Security;
use App\Entity\Account;
use App\Security\KeycloakAuthenticator;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
use KnpU\OAuth2ClientBundle\Client\OAuth2ClientInterface;
use League\OAuth2\Client\Provider\GenericResourceOwner;
use League\OAuth2\Client\Token\AccessToken;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Stevenmaguire\OAuth2\Client\Provider\KeycloakResourceOwner;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
#[AllowMockObjectsWithoutExpectations]
class KeycloakAuthenticatorTest extends TestCase
{
private $clientRegistry;
private $entityManager;
private $router;
private $authenticator;
protected function setUp(): void
{
$this->clientRegistry = $this->createMock(ClientRegistry::class);
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->router = $this->createMock(RouterInterface::class);
$this->authenticator = new KeycloakAuthenticator(
$this->clientRegistry,
$this->entityManager,
$this->router
);
}
public function testSupports()
{
$request = Request::create('/connect/keycloak/check');
$request->attributes->set('_route', 'connect_keycloak_check');
$this->assertTrue($this->authenticator->supports($request));
}
public function testAuthenticateExistingUser()
{
$request = Request::create('/connect/keycloak/check');
$client = $this->createMock(OAuth2ClientInterface::class);
$this->clientRegistry->method('getClient')->with('keycloak')->willReturn($client);
$accessToken = new AccessToken(['access_token' => 'token']);
$client->method('getAccessToken')->willReturn($accessToken);
// Mock Keycloak User
$keycloakUser = $this->createMock(KeycloakResourceOwner::class);
$keycloakUser->method('getId')->willReturn('keycloak-id-123');
$keycloakUser->method('getEmail')->willReturn('user@test.com');
$client->method('fetchUserFromToken')->willReturn($keycloakUser);
// Mock Repository
$repository = $this->createMock(EntityRepository::class);
$this->entityManager->method('getRepository')->with(Account::class)->willReturn($repository);
// Existing user by Keycloak ID
$existingUser = new Account();
$repository->method('findOneBy')->willReturnMap([
[['keycloakId' => 'keycloak-id-123'], null, $existingUser]
]);
$passport = $this->authenticator->authenticate($request);
$this->assertInstanceOf(Passport::class, $passport);
$userBadge = $passport->getBadge(UserBadge::class);
$userLoader = $userBadge->getUserLoader();
$loadedUser = $userLoader();
$this->assertSame($existingUser, $loadedUser);
}
}

85
tests/Security/LoginFormAuthenticatorTest.php Normal file
View File

@@ -0,0 +1,85 @@
<?php
namespace App\Tests\Security;
use App\Entity\Account;
use App\Security\LoginFormAuthenticator;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Exception\CustomUserMessageAuthenticationException;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
#[AllowMockObjectsWithoutExpectations]
class LoginFormAuthenticatorTest extends TestCase
{
private $entityManager;
private $urlGenerator;
private $security;
private $authenticator;
protected function setUp(): void
{
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$this->security = $this->createMock(Security::class);
$this->authenticator = new LoginFormAuthenticator(
$this->entityManager,
$this->urlGenerator,
$this->security
);
}
public function testSupports()
{
$request = Request::create('/login', 'POST');
$request->attributes->set('_route', 'app_home');
$request->headers->set('HOST', 'intranet.ludikevent.fr');
$this->assertTrue($this->authenticator->supports($request));
}
public function testAuthenticateUserNotFound()
{
$request = Request::create('/login', 'POST', [
'_username' => 'unknown@test.com',
'_password' => 'pass',
'_csrf_token' => 'token'
]);
$request->setSession($this->createMock(SessionInterface::class));
$repo = $this->createMock(EntityRepository::class);
$this->entityManager->method('getRepository')->willReturn($repo);
$repo->method('findOneBy')->willReturn(null);
$this->expectException(CustomUserMessageAuthenticationException::class);
$passport = $this->authenticator->authenticate($request);
$passport->getBadge(\Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge::class)->getUserLoader()('unknown@test.com');
}
public function testOnAuthenticationSuccess()
{
$request = Request::create('/login');
$request->setSession($this->createMock(SessionInterface::class));
$token = $this->createMock(TokenInterface::class);
$this->urlGenerator->expects($this->once())
->method('generate')
->with('app_crm')
->willReturn('/crm');
$response = $this->authenticator->onAuthenticationSuccess($request, $token, 'main');
$this->assertInstanceOf(RedirectResponse::class, $response);
$this->assertEquals('/crm', $response->getTargetUrl());
}
}

75
tests/Security/MaintenanceListenerTest.php Normal file
View File

@@ -0,0 +1,75 @@
<?php
namespace App\Tests\Security;
use App\Security\MaintenanceListener;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Twig\Environment;
#[AllowMockObjectsWithoutExpectations]
class MaintenanceListenerTest extends TestCase
{
private $twig;
private $tempDir;
private $listener;
protected function setUp(): void
{
$this->twig = $this->createMock(Environment::class);
$this->tempDir = sys_get_temp_dir() . '/maintenance_test_' . uniqid();
mkdir($this->tempDir . '/var', 0777, true);
$this->listener = new MaintenanceListener($this->twig, $this->tempDir);
}
protected function tearDown(): void
{
$this->removeDirectory($this->tempDir);
}
public function testOnKernelRequestMaintenanceFileExists()
{
touch($this->tempDir . '/var/.maintenance');
$kernel = $this->createMock(HttpKernelInterface::class);
$request = Request::create('/');
$event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
$this->twig->expects($this->once())
->method('render')
->with('security/maintenance.twig')
->willReturn('Maintenance Mode');
$this->listener->onKernelRequest($event);
$response = $event->getResponse();
$this->assertInstanceOf(Response::class, $response);
$this->assertEquals(503, $response->getStatusCode());
$this->assertEquals('Maintenance Mode', $response->getContent());
}
public function testOnKernelRequestNoMaintenanceFile()
{
$kernel = $this->createMock(HttpKernelInterface::class);
$request = Request::create('/');
$event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
$this->listener->onKernelRequest($event);
$this->assertNull($event->getResponse());
}
private function removeDirectory($dir) {
if (!is_dir($dir)) return;
$files = array_diff(scandir($dir), array('.','..'));
foreach ($files as $file) {
(is_dir("$dir/$file")) ? $this->removeDirectory("$dir/$file") : unlink("$dir/$file");
}
rmdir($dir);
}
}

36
tests/Security/PasswordGeneratorTest.php Normal file
View File

@@ -0,0 +1,36 @@
<?php
namespace App\Tests\Security;
use App\Security\PasswordGenerator;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
#[AllowMockObjectsWithoutExpectations]
class PasswordGeneratorTest extends TestCase
{
public function testGenerateLength()
{
$generator = new PasswordGenerator(16);
$password = $generator->generate();
$this->assertEquals(16, strlen($password));
}
public function testGenerateContainsRequiredCharacters()
{
$generator = new PasswordGenerator(12);
$password = $generator->generate();
$this->assertMatchesRegularExpression('/[a-z]/', $password);
$this->assertMatchesRegularExpression('/[A-Z]/', $password);
$this->assertMatchesRegularExpression('/[0-9]/', $password);
$this->assertMatchesRegularExpression('/[@#_\-]/', $password);
}
public function testInvalidLengthThrowsException()
{
$this->expectException(\InvalidArgumentException::class);
new PasswordGenerator(3);
}
}

76
tests/Security/RedirecListenerTest.php Normal file
View File

@@ -0,0 +1,76 @@
<?php
namespace App\Tests\Security;
use App\Security\RedirecListener;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\ResponseEvent;
use Symfony\Component\HttpKernel\HttpKernelInterface;
#[AllowMockObjectsWithoutExpectations]
class RedirecListenerTest extends TestCase
{
private $listener;
protected function setUp(): void
{
// We need to control $_ENV['APP_ENV'] for the constructor logic
$_ENV['APP_ENV'] = 'prod';
$this->listener = new RedirecListener();
}
public function testIntranetRootRedirect()
{
$kernel = $this->createMock(HttpKernelInterface::class);
$request = Request::create('/');
$request->headers->set('HOST', 'intranet.ludikevent.fr');
$response = new Response();
$event = new ResponseEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST, $response);
$this->listener->onResponse($event);
$newResponse = $event->getResponse();
$this->assertInstanceOf(RedirectResponse::class, $newResponse);
$this->assertEquals('https://intranet.ludikevent.fr/intranet', $newResponse->getTargetUrl());
}
public function testReservationRedirect()
{
$kernel = $this->createMock(HttpKernelInterface::class);
$request = Request::create('/reservation/catalogue');
$request->headers->set('HOST', 'reservation.ludikevent.fr');
$response = new Response();
$event = new ResponseEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST, $response);
$this->listener->onResponse($event);
$newResponse = $event->getResponse();
$this->assertInstanceOf(RedirectResponse::class, $newResponse);
$this->assertEquals('https://reservation.ludikevent.fr/catalogue', $newResponse->getTargetUrl());
$this->assertEquals(Response::HTTP_MOVED_PERMANENTLY, $newResponse->getStatusCode());
}
public function testDevNgrokRedirect()
{
$_ENV['APP_ENV'] = 'dev';
$listener = new RedirecListener(); // Re-instantiate to pick up dev env
$kernel = $this->createMock(HttpKernelInterface::class);
$request = Request::create('/some/path?foo=bar');
$request->headers->set('HOST', 'my-app.ngrok-free.app');
$response = new Response();
$event = new ResponseEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST, $response);
$listener->onResponse($event);
$newResponse = $event->getResponse();
$this->assertInstanceOf(RedirectResponse::class, $newResponse);
$this->assertEquals('https://esyweb.local/some/path?foo=bar', $newResponse->getTargetUrl());
$_ENV['APP_ENV'] = 'prod'; // Restore
}
}

79
tests/Security/SiteMapListenerTest.php Normal file
View File

@@ -0,0 +1,79 @@
<?php
namespace App\Tests\Security;
use App\Entity\Formules;
use App\Entity\Product;
use App\Repository\FormulesRepository;
use App\Repository\OptionsRepository;
use App\Repository\ProductRepository;
use App\Security\SiteMapListener;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Presta\SitemapBundle\Event\SitemapPopulateEvent;
use Presta\SitemapBundle\Service\UrlContainerInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Vich\UploaderBundle\Storage\StorageInterface;
use Vich\UploaderBundle\Templating\Helper\UploaderHelper;
#[AllowMockObjectsWithoutExpectations]
class SiteMapListenerTest extends TestCase
{
private $uploaderHelper;
private $storage;
private $optionsRepository;
private $productRepository;
private $formulesRepository;
private $entityManager;
private $listener;
protected function setUp(): void
{
$this->storage = $this->createMock(StorageInterface::class);
$this->uploaderHelper = new UploaderHelper($this->storage); // Instantiate real class
$this->optionsRepository = $this->createMock(OptionsRepository::class);
$this->productRepository = $this->createMock(ProductRepository::class);
$this->formulesRepository = $this->createMock(FormulesRepository::class);
$this->entityManager = $this->createMock(EntityManagerInterface::class);
$this->listener = new SiteMapListener(
$this->uploaderHelper,
$this->optionsRepository,
$this->productRepository,
$this->formulesRepository,
$this->entityManager
);
}
public function testPopulate()
{
$urlContainer = $this->createMock(UrlContainerInterface::class);
$urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$event = new SitemapPopulateEvent($urlContainer, $urlGenerator);
$urlGenerator->method('generate')->willReturn('https://example.com/page');
// Mock Data
$formule = $this->createMock(Formules::class);
$formule->method('slug')->willReturn('f-1');
$formule->method('getUpdatedAt')->willReturn(new \DateTimeImmutable());
$this->formulesRepository->method('findBy')->willReturn([$formule]);
// Mock UploaderHelper behavior via Storage
$this->storage->method('resolveUri')->willReturn('/images/formule.jpg');
$product = $this->createMock(Product::class);
$product->method('slug')->willReturn('p-1');
$product->method('getUpdatedAt')->willReturn(new \DateTimeImmutable());
$product->method('getName')->willReturn('Prod 1');
$this->productRepository->method('findAll')->willReturn([$product]);
$this->optionsRepository->method('findAll')->willReturn([]);
$urlContainer->expects($this->atLeastOnce())->method('addUrl');
$this->listener->populate($event);
}
}

49
tests/Security/UserCheckerTest.php Normal file
View File

@@ -0,0 +1,49 @@
<?php
namespace App\Tests\Security;
use App\Entity\Account;
use App\Security\UserChecker;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Security\Core\Exception\CustomUserMessageAccountStatusException;
use Symfony\Component\Security\Core\User\UserInterface;
#[AllowMockObjectsWithoutExpectations]
class UserCheckerTest extends TestCase
{
private $checker;
protected function setUp(): void
{
$this->checker = new UserChecker();
}
public function testCheckPreAuthActiveUser()
{
$user = $this->createMock(Account::class);
$user->method('isActif')->willReturn(true);
$this->checker->checkPreAuth($user);
$this->assertTrue(true); // No exception thrown
}
public function testCheckPreAuthInactiveUserThrowsException()
{
$user = $this->createMock(Account::class);
$user->method('isActif')->willReturn(false);
$this->expectException(CustomUserMessageAccountStatusException::class);
$this->expectExceptionMessage('Votre compte a été désactivé.');
$this->checker->checkPreAuth($user);
}
public function testCheckPreAuthNonAccountUserIgnores()
{
$user = $this->createMock(UserInterface::class);
$this->checker->checkPreAuth($user);
$this->assertTrue(true);
}
}

60
tests/Service/AI/GeminiClientTest.php Normal file
View File

@@ -0,0 +1,60 @@
<?php
namespace App\Tests\Service\AI;
use App\Service\AI\GeminiClient;
use GeminiAPI\Client;
use GeminiAPI\GenerativeModel;
use GeminiAPI\Resources\Parts\TextPart;
use GeminiAPI\Responses\GenerateContentResponse;
use PHPUnit\Framework\TestCase;
class GeminiClientTest extends TestCase
{
public function testGenerateFriendlyMessageSuccess(): void
{
// Mock the response
$responseMock = $this->createStub(GenerateContentResponse::class);
$responseMock->method('text')
->willReturn('This is a friendly update.');
// Mock the model
$modelMock = $this->createMock(GenerativeModel::class);
$modelMock->expects($this->once())
->method('generateContent')
->with($this->isInstanceOf(TextPart::class))
->willReturn($responseMock);
// Mock the client
$clientMock = $this->createMock(Client::class);
$clientMock->expects($this->once())
->method('withV1BetaVersion')
->willReturnSelf();
$clientMock->expects($this->once())
->method('generativeModel')
->with('gemini-3-pro-preview')
->willReturn($modelMock);
// Instantiate GeminiClient with mocked Client
$geminiClient = new GeminiClient('fake-api-key', $clientMock);
$result = $geminiClient->generateFriendlyMessage('Raw technical message');
$this->assertEquals('This is a friendly update.', $result);
}
public function testGenerateFriendlyMessageException(): void
{
// Mock the client to throw an exception
$clientMock = $this->createStub(Client::class);
$clientMock->method('withV1BetaVersion')
->willThrowException(new \Exception('API Error'));
// Instantiate GeminiClient with mocked Client
$geminiClient = new GeminiClient('fake-api-key', $clientMock);
$result = $geminiClient->generateFriendlyMessage('Raw technical message');
$this->assertNull($result);
}
}

73
tests/Service/Generator/TempPasswordGeneratorTest.php Normal file
View File

@@ -0,0 +1,73 @@
<?php
namespace App\Tests\Service\Generator;
use App\Service\Generator\TempPasswordGenerator;
use PHPUnit\Framework\TestCase;
class TempPasswordGeneratorTest extends TestCase
{
public function testGenerateDefaultLength(): void
{
$password = TempPasswordGenerator::generate();
$this->assertEquals(12, strlen($password));
}
public function testGenerateCustomLength(): void
{
$length = 16;
$password = TempPasswordGenerator::generate($length);
$this->assertEquals($length, strlen($password));
}
public function testGenerateInvalidLength(): void
{
$password = TempPasswordGenerator::generate(-5);
$this->assertEquals(12, strlen($password)); // Should fallback to default
}
public function testGenerateCustomCharacters(): void
{
$chars = 'ABC';
$password = TempPasswordGenerator::generate(10, $chars);
$this->assertEquals(10, strlen($password));
$this->assertMatchesRegularExpression('/^[ABC]+$/', $password);
}
public function testIsComplexValid(): void
{
// Needs 8+ chars, Upper, Lower, Digit, Special
$password = 'Ab1!defg';
$this->assertTrue(TempPasswordGenerator::isComplex($password));
}
public function testIsComplexTooShort(): void
{
$password = 'Ab1!de'; // 6 chars
$this->assertFalse(TempPasswordGenerator::isComplex($password));
}
public function testIsComplexMissingUpper(): void
{
$password = 'ab1!defg';
$this->assertFalse(TempPasswordGenerator::isComplex($password));
}
public function testIsComplexMissingLower(): void
{
$password = 'AB1!DEFG';
$this->assertFalse(TempPasswordGenerator::isComplex($password));
}
public function testIsComplexMissingDigit(): void
{
$password = 'Abc!defg';
$this->assertFalse(TempPasswordGenerator::isComplex($password));
}
public function testIsComplexMissingSpecial(): void
{
$password = 'Ab12defg';
$this->assertFalse(TempPasswordGenerator::isComplex($password));
}
}

21
tests/Service/Mailer/Event/CreatedAdminEventTest.php Normal file
View File

@@ -0,0 +1,21 @@
<?php
namespace App\Tests\Service\Mailer\Event;
use App\Entity\Account;
use App\Service\Mailer\Event\CreatedAdminEvent;
use PHPUnit\Framework\TestCase;
class CreatedAdminEventTest extends TestCase
{
public function testGetters(): void
{
$account = new Account();
$password = 'secret123';
$event = new CreatedAdminEvent($account, $password);
$this->assertSame($account, $event->getAccount());
$this->assertSame($password, $event->getPassword());
}
}

50
tests/Service/Mailer/MailerSubscriberTest.php Normal file
View File

@@ -0,0 +1,50 @@
<?php
namespace App\Tests\Service\Mailer;
use App\Entity\Account;
use App\Service\Mailer\Event\CreatedAdminEvent;
use App\Service\Mailer\Mailer;
use App\Service\Mailer\MailerSubscriber;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
class MailerSubscriberTest extends TestCase
{
public function testOnAdminEvent(): void
{
$urlGenerator = $this->createMock(UrlGeneratorInterface::class);
$mailer = $this->createMock(Mailer::class);
$subscriber = new MailerSubscriber($urlGenerator, $mailer);
$account = $this->createStub(Account::class);
$account->method('getEmail')->willReturn('test@example.com');
$account->method('getUsername')->willReturn('testuser');
$password = 'secret';
$event = new CreatedAdminEvent($account, $password);
$urlGenerator->expects($this->once())
->method('generate')
->with('app_home')
->willReturn('http://example.com/home');
$mailer->expects($this->once())
->method('send')
->with(
'test@example.com',
'testuser',
"[LudikEvent] - Création d'un compte administrateur",
"mails/new_admin.twig",
[
'username' => 'testuser',
'password' => 'secret',
'url' => 'http://example.com/home',
]
);
$subscriber->onAdminEvent($event);
}
}

62
tests/Service/Mailer/MailerTest.php Normal file
View File

@@ -0,0 +1,62 @@
<?php
namespace App\Tests\Service\Mailer;
use App\Service\Mailer\Mailer;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpKernel\Profiler\Profiler;
use Symfony\Component\Mailer\MailerInterface;
use Symfony\Component\Mime\Email;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Twig\Environment;
class MailerTest extends TestCase
{
public function testSend(): void
{
$symfonyMailer = $this->createMock(MailerInterface::class);
$entityManager = $this->createStub(EntityManagerInterface::class);
$urlGenerator = $this->createStub(UrlGeneratorInterface::class);
$profiler = $this->createStub(Profiler::class);
$twig = $this->createMock(Environment::class);
$mailer = new Mailer(
$symfonyMailer,
$entityManager,
$urlGenerator,
$profiler,
$twig
);
$template = 'mails/test.twig';
$data = ['foo' => 'bar'];
// Mock Twig rendering
// 1. First call for MJML content
// 2. Second call for Text content (fallback)
$twig->expects($this->exactly(2))
->method('render')
->willReturnCallback(function ($tpl, $ctx) use ($template) {
if ($tpl === $template) {
return '<mjml><mj-body>Hello</mj-body></mjml>';
}
if ($tpl === 'txt-' . $template) {
return 'Hello Text';
}
return '';
});
$symfonyMailer->expects($this->once())
->method('send')
->with($this->isInstanceOf(Email::class));
$mailer->send(
'dest@example.com',
'Dest Name',
'Subject',
$template,
$data
);
}
}

20
tests/Service/Media/VideoThumbnailerTest.php Normal file
View File

@@ -0,0 +1,20 @@
<?php
namespace App\Tests\Service\Media;
use App\Service\Media\VideoThumbnailer;
use PHPUnit\Framework\TestCase;
class VideoThumbnailerTest extends TestCase
{
public function testGenerateThumbnailFileNotFound(): void
{
$thumbnailer = new VideoThumbnailer();
// Either RuntimeException (from Process check) or just ProcessFailedException if checking output
// The code throws RuntimeException if !isSuccessful()
$this->expectException(\RuntimeException::class);
$thumbnailer->generateThumbnail('non_existent_video_file.mp4', 'output_thumb.jpg');
}
}

59
tests/Service/Pdf/ContratPdfServiceTest.php Normal file
View File

@@ -0,0 +1,59 @@
<?php
namespace App\Tests\Service\Pdf;
use App\Entity\Contrats;
use App\Entity\Customer;
use App\Service\Pdf\ContratPdfService;
use Doctrine\Common\Collections\ArrayCollection;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpKernel\KernelInterface;
class ContratPdfServiceTest extends TestCase
{
public function testGenerate(): void
{
$kernel = $this->createStub(KernelInterface::class);
$kernel->method('getProjectDir')->willReturn(sys_get_temp_dir());
// Create dummy favicon for logo check
$faviconDir = sys_get_temp_dir() . '/public/provider/images';
if (!is_dir($faviconDir)) {
mkdir($faviconDir, 0777, true);
}
$pngData = base64_decode('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==');
file_put_contents($faviconDir . '/favicon.png', $pngData);
$contrat = $this->createStub(Contrats::class);
$customer = $this->createStub(Customer::class);
$contrat->method('getNumReservation')->willReturn('RES-123');
$contrat->method('getCustomer')->willReturn($customer);
$contrat->method('getAddressEvent')->willReturn('123 Event St');
$contrat->method('getZipCodeEvent')->willReturn('75000');
$contrat->method('getTownEvent')->willReturn('Paris');
$contrat->method('getDateAt')->willReturn(new \DateTimeImmutable('2023-01-01'));
$contrat->method('getEndAt')->willReturn(new \DateTimeImmutable('2023-01-02')); // 2 days
$contrat->method('getContratsLines')->willReturn(new ArrayCollection([]));
$contrat->method('getContratsOptions')->willReturn(new ArrayCollection([]));
// Mock nullable strings
$contrat->method('getTypeSol')->willReturn('Herbe');
$contrat->method('getDistancePower')->willReturn(10.0);
$contrat->method('getPente')->willReturn('Plat');
$contrat->method('getAccess')->willReturn('Facile');
$contrat->method('getAddress2Event')->willReturn(null);
$contrat->method('getAddress3Event')->willReturn(null);
$customer->method('getName')->willReturn('Doe');
$customer->method('getSurname')->willReturn('John');
$customer->method('getPhone')->willReturn('0102030405');
$customer->method('getEmail')->willReturn('john@example.com');
$pdfService = new ContratPdfService($kernel, $contrat);
$content = $pdfService->generate();
$this->assertNotEmpty($content);
$this->assertStringStartsWith('%PDF', $content);
}
}

50
tests/Service/Pdf/DevisPdfServiceTest.php Normal file
View File

@@ -0,0 +1,50 @@
<?php
namespace App\Tests\Service\Pdf;
use App\Entity\Customer;
use App\Entity\Devis;
use App\Repository\ProductRepository;
use App\Service\Pdf\DevisPdfService;
use Doctrine\Common\Collections\ArrayCollection;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpKernel\KernelInterface;
class DevisPdfServiceTest extends TestCase
{
public function testGenerate(): void
{
$kernel = $this->createStub(KernelInterface::class);
$kernel->method('getProjectDir')->willReturn(sys_get_temp_dir());
// Create dummy favicon for logo check
$faviconDir = sys_get_temp_dir() . '/public/provider/images';
if (!is_dir($faviconDir)) {
mkdir($faviconDir, 0777, true);
}
$pngData = base64_decode('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==');
file_put_contents($faviconDir . '/favicon.png', $pngData);
$devis = $this->createStub(Devis::class);
$productRepository = $this->createStub(ProductRepository::class);
$customer = $this->createStub(Customer::class);
$devis->method('getNum')->willReturn('DEV-001');
$devis->method('getCustomer')->willReturn($customer);
$devis->method('getBillAddress')->willReturn(null); // Simplify
$devis->method('getAddressShip')->willReturn(null);
$devis->method('getStartAt')->willReturn(new \DateTimeImmutable('2023-01-01'));
$devis->method('getEndAt')->willReturn(new \DateTimeImmutable('2023-01-02'));
$devis->method('getDevisLines')->willReturn(new ArrayCollection([]));
$devis->method('getDevisOptions')->willReturn(new ArrayCollection([]));
$customer->method('getName')->willReturn('Client SAS');
$customer->method('getEmail')->willReturn('client@example.com');
$pdfService = new DevisPdfService($kernel, $devis, $productRepository);
$content = $pdfService->generate();
$this->assertNotEmpty($content);
$this->assertStringStartsWith('%PDF', $content);
}
}

49
tests/Service/Pdf/PlPdfTest.php Normal file
View File

@@ -0,0 +1,49 @@
<?php
namespace App\Tests\Service\Pdf;
use App\Entity\Contrats;
use App\Entity\ContratsPayments;
use App\Entity\Customer;
use App\Service\Pdf\PlPdf;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpKernel\KernelInterface;
class PlPdfTest extends TestCase
{
public function testGenerate(): void
{
$kernel = $this->createStub(KernelInterface::class);
$kernel->method('getProjectDir')->willReturn(sys_get_temp_dir());
// Create dummy favicon for logo check
$faviconDir = sys_get_temp_dir() . '/public/provider/images';
if (!is_dir($faviconDir)) {
mkdir($faviconDir, 0777, true);
}
$pngData = base64_decode('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==');
file_put_contents($faviconDir . '/favicon.png', $pngData);
$contrat = $this->createStub(Contrats::class);
$contratsPayments = $this->createStub(ContratsPayments::class);
$customer = $this->createStub(Customer::class);
$contrat->method('getNumReservation')->willReturn('RES-123');
$contrat->method('getCustomer')->willReturn($customer);
$customer->method('getSurname')->willReturn('John');
$customer->method('getName')->willReturn('Doe');
$customer->method('getEmail')->willReturn('john@example.com');
$contratsPayments->method('getAmount')->willReturn(100.0);
$contratsPayments->method('getValidateAt')->willReturn(new \DateTimeImmutable('2023-01-01 12:00:00'));
$contratsPayments->method('getCard')->willReturn(['type' => 'Carte Bancaire']);
$contratsPayments->method('getPaymentId')->willReturn('TX-999');
$pdfService = new PlPdf($kernel, $contratsPayments, $contrat);
$content = $pdfService->generate();
$this->assertNotEmpty($content);
$this->assertStringStartsWith('%PDF', $content);
}
}

17
tests/Service/ResetPassword/Event/ResetPasswordConfirmEventTest.php Normal file
View File

@@ -0,0 +1,17 @@
<?php
namespace App\Tests\Service\ResetPassword\Event;
use App\Service\ResetPassword\Event\ResetPasswordConfirmEvent;
use PHPUnit\Framework\TestCase;
class ResetPasswordConfirmEventTest extends TestCase
{
public function testGetSetPassword(): void
{
$event = new ResetPasswordConfirmEvent();
$password = 'newpass';
$event->setPassword($password);
$this->assertEquals($password, $event->getPassword());
}
}

17
tests/Service/ResetPassword/Event/ResetPasswordEventTest.php Normal file
View File

@@ -0,0 +1,17 @@
<?php
namespace App\Tests\Service\ResetPassword\Event;
use App\Service\ResetPassword\Event\ResetPasswordEvent;
use PHPUnit\Framework\TestCase;
class ResetPasswordEventTest extends TestCase
{
public function testGetSetEmail(): void
{
$event = new ResetPasswordEvent();
$email = 'test@example.com';
$event->setEmail($email);
$this->assertEquals($email, $event->getEmail());
}
}

76
tests/Service/ResetPassword/ResetPasswordSubscriberTest.php Normal file
View File

@@ -0,0 +1,76 @@
<?php
namespace App\Tests\Service\ResetPassword;
use App\Entity\Account;
use App\Entity\AccountResetPasswordRequest;
use App\Service\Mailer\Mailer;
use App\Service\ResetPassword\Event\ResetPasswordEvent;
use App\Service\ResetPassword\ResetPasswordSubscriber;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
class ResetPasswordSubscriberTest extends TestCase
{
public function testOnResetPasswordAccountNotFound(): void
{
$urlGenerator = $this->createStub(UrlGeneratorInterface::class);
$entityManager = $this->createStub(EntityManagerInterface::class);
$mailer = $this->createMock(Mailer::class);
$requestStack = $this->createStub(RequestStack::class);
$subscriber = new ResetPasswordSubscriber($urlGenerator, $entityManager, $mailer, $requestStack);
$event = new ResetPasswordEvent();
$event->setEmail('unknown@example.com');
$repo = $this->createStub(EntityRepository::class);
$entityManager->method('getRepository')->with(Account::class)->willReturn($repo);
$repo->method('findOneBy')->with(['email' => 'unknown@example.com'])->willReturn(null);
$mailer->expects($this->never())->method('send');
$subscriber->onResetPassword($event);
}
public function testOnResetPasswordSuccess(): void
{
$urlGenerator = $this->createStub(UrlGeneratorInterface::class);
$entityManager = $this->createMock(EntityManagerInterface::class);
$mailer = $this->createMock(Mailer::class);
$requestStack = $this->createStub(RequestStack::class);
$subscriber = new ResetPasswordSubscriber($urlGenerator, $entityManager, $mailer, $requestStack);
$event = new ResetPasswordEvent();
$event->setEmail('user@example.com');
$account = $this->createStub(Account::class);
$account->method('getEmail')->willReturn('user@example.com');
$account->method('getUsername')->willReturn('user');
$account->method('getId')->willReturn(1);
$repoAccount = $this->createStub(EntityRepository::class);
$repoRequest = $this->createStub(EntityRepository::class);
$entityManager->method('getRepository')->willReturnMap([
[Account::class, $repoAccount],
[AccountResetPasswordRequest::class, $repoRequest],
]);
$repoAccount->method('findOneBy')->with(['email' => 'user@example.com'])->willReturn($account);
$repoRequest->method('findOneBy')->with(['Account' => $account])->willReturn(null);
$entityManager->expects($this->once())->method('persist')->with($this->isInstanceOf(AccountResetPasswordRequest::class));
$entityManager->expects($this->once())->method('flush');
$urlGenerator->method('generate')->willReturn('http://reset-link');
$mailer->expects($this->once())->method('send');
$subscriber->onResetPassword($event);
}
}

39
tests/Service/Search/ClientTest.php Normal file
View File

@@ -0,0 +1,39 @@
<?php
namespace App\Tests\Service\Search;
use App\Service\Search\Client;
use Meilisearch\Client as MeilisearchClient;
use Meilisearch\Endpoints\Indexes;
use Meilisearch\Search\SearchResult;
use PHPUnit\Framework\TestCase;
class ClientTest extends TestCase
{
public function testStatus(): void
{
$msClient = $this->createStub(MeilisearchClient::class);
$msClient->method('health')->willReturn(['status' => 'available']);
$client = new Client($msClient);
$this->assertTrue($client->status());
}
public function testSearch(): void
{
$msClient = $this->createStub(MeilisearchClient::class);
$indexMock = $this->createStub(Indexes::class);
$msClient->method('index')->willReturn($indexMock);
// Mock SearchResult
$searchResult = $this->createStub(SearchResult::class);
$searchResult->method('toArray')->willReturn(['hits' => []]);
$indexMock->method('search')->willReturn($searchResult);
$client = new Client($msClient);
$result = $client->search('product', 'query');
$this->assertIsArray($result);
}
}

75
tests/Service/Signature/ClientTest.php Normal file
View File

@@ -0,0 +1,75 @@
<?php
namespace App\Tests\Service\Signature;
use App\Entity\Contrats;
use App\Entity\Customer;
use App\Service\Signature\Client;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpKernel\KernelInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Vich\UploaderBundle\Storage\StorageInterface;
class ClientTest extends TestCase
{
public function testStatus(): void
{
$requestStack = $this->createStub(RequestStack::class);
$urlGenerator = $this->createStub(UrlGeneratorInterface::class);
$entityManager = $this->createStub(EntityManagerInterface::class);
$kernel = $this->createStub(KernelInterface::class);
$storage = $this->createStub(StorageInterface::class);
$docuseal = $this->createStub(\Docuseal\Api::class);
$docuseal->method('listTemplates')->willReturn([]);
$client = new Client($requestStack, $urlGenerator, $entityManager, $kernel, $storage, $docuseal);
$this->assertTrue($client->status());
}
public function testCreateSubmissionContrat(): void
{
$requestStack = $this->createStub(RequestStack::class);
$urlGenerator = $this->createStub(UrlGeneratorInterface::class);
$entityManager = $this->createStub(EntityManagerInterface::class);
$kernel = $this->createStub(KernelInterface::class);
$storage = $this->createStub(StorageInterface::class);
$docuseal = $this->createStub(\Docuseal\Api::class);
$kernel->method('getProjectDir')->willReturn(sys_get_temp_dir());
$client = new Client($requestStack, $urlGenerator, $entityManager, $kernel, $storage, $docuseal);
$contrat = $this->createMock(Contrats::class);
$customer = $this->createStub(Customer::class);
$contrat->method('getCustomer')->willReturn($customer);
$contrat->method('getNumReservation')->willReturn('RES-123');
$contrat->method('getId')->willReturn(1);
$customer->method('getEmail')->willReturn('test@example.com');
$customer->method('getName')->willReturn('Doe');
$customer->method('getSurname')->willReturn('John');
$docuseal->method('createSubmissionFromPdf')->willReturn([
'submitters' => [
1 => ['id' => 'sub_123']
]
]);
$docuseal->method('getSubmitter')->with('sub_123')->willReturn(['slug' => 'slug_123']);
$contrat->expects($this->exactly(2))
->method('getSignID')
->willReturnOnConsecutiveCalls(null, 'sub_123');
$contrat->expects($this->once())->method('setSignID')->with('sub_123');
$link = $client->createSubmissionContrat($contrat);
$this->assertStringContainsString('/s/slug_123', $link);
}
}

37
tests/Service/Stripe/ClientTest.php Normal file
View File

@@ -0,0 +1,37 @@
<?php
namespace App\Tests\Service\Stripe;
use App\Service\Stripe\Client;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\TestCase;
use Stripe\Service\AccountService;
use Stripe\StripeClient;
use Vich\UploaderBundle\Storage\StorageInterface;
use Vich\UploaderBundle\Templating\Helper\UploaderHelper;
class ClientTest extends TestCase
{
public function testCheckSuccess(): void
{
$em = $this->createStub(EntityManagerInterface::class);
$storage = $this->createStub(StorageInterface::class);
$uploaderHelper = new UploaderHelper($storage);
$stripeClient = $this->createStub(StripeClient::class);
$accountService = $this->createStub(AccountService::class);
$accountService->method('all')->willReturn(new \Stripe\Collection());
$stripeClient->method('__get')->willReturnMap([
['accounts', $accountService]
]);
$client = new Client($em, $uploaderHelper, $stripeClient);
$result = $client->check();
$this->assertTrue($result['state']);
}
}

26
tests/Service/System/DatabaseDumperTest.php Normal file
View File

@@ -0,0 +1,26 @@
<?php
namespace App\Tests\Service\System;
use App\Service\System\DatabaseDumper;
use PHPUnit\Framework\TestCase;
class DatabaseDumperTest extends TestCase
{
public function testDumpSuccess(): void
{
$dumper = new class extends DatabaseDumper {
public string $lastCommand = '';
protected function execute(string $command, &$output, &$returnCode): void
{
$this->lastCommand = $command;
$returnCode = 0;
}
};
$dumper->dump('postgresql://user:pass@localhost:5432/db', 'dump.sql');
$this->assertStringContainsString('pg_dump', $dumper->lastCommand);
}
}

21
tests/Service/System/GitClientTest.php Normal file
View File

@@ -0,0 +1,21 @@
<?php
namespace App\Tests\Service\System;
use App\Service\System\GitClient;
use PHPUnit\Framework\TestCase;
class GitClientTest extends TestCase
{
public function testGetLastCommitInfo(): void
{
$client = new GitClient();
$info = $client->getLastCommitInfo('.');
$this->assertIsArray($info);
$this->assertArrayHasKey('message', $info);
$this->assertArrayHasKey('date', $info);
$this->assertArrayHasKey('hash', $info);
}
}

39
tests/Service/System/ZipArchiverTest.php Normal file
View File

@@ -0,0 +1,39 @@
<?php
namespace App\Tests\Service\System;
use App\Service\System\ZipArchiver;
use PHPUnit\Framework\TestCase;
class ZipArchiverTest extends TestCase
{
public function testCreateArchive(): void
{
$archiver = new ZipArchiver();
$tmpDir = sys_get_temp_dir() . '/zip_test_' . uniqid();
mkdir($tmpDir);
file_put_contents($tmpDir . '/file.txt', 'content');
$zipPath = $tmpDir . '/archive.zip';
$sqlPath = $tmpDir . '/dump.sql';
file_put_contents($sqlPath, 'SQL');
$archiver->createArchive($zipPath, $sqlPath, ['files' => $tmpDir]);
$this->assertFileExists($zipPath);
// Check content
$zip = new \ZipArchive();
$zip->open($zipPath);
$this->assertNotFalse($zip->getFromName('database.sql'));
$this->assertNotFalse($zip->getFromName('files/file.txt')); // Might be slightly different path depending on recursive iterator
$zip->close();
// Cleanup
unlink($zipPath);
unlink($sqlPath);
unlink($tmpDir . '/file.txt');
rmdir($tmpDir);
}
}

69
tests/Twig/StripeExtensionTest.php Normal file
View File

@@ -0,0 +1,69 @@
<?php
namespace App\Tests\Twig;
use App\Entity\Contrats;
use App\Entity\Devis;
use App\Service\Signature\Client as SignatureClient;
use App\Service\Stripe\Client as StripeClientService;
use App\Twig\StripeExtension;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\TestCase;
use Vich\UploaderBundle\Storage\StorageInterface;
use Vich\UploaderBundle\Templating\Helper\UploaderHelper;
class StripeExtensionTest extends TestCase
{
public function testGetFiltersAndFunctions(): void
{
$storage = $this->createStub(StorageInterface::class);
$uploaderHelper = new UploaderHelper($storage);
$signatureClient = $this->createStub(SignatureClient::class);
$stripeClient = $this->createStub(StripeClientService::class);
$em = $this->createStub(EntityManagerInterface::class);
$extension = new StripeExtension($uploaderHelper, $signatureClient, $stripeClient, $em);
$this->assertIsArray($extension->getFilters());
$this->assertIsArray($extension->getFunctions());
}
public function testTotalQuoto(): void
{
$storage = $this->createStub(StorageInterface::class);
$uploaderHelper = new UploaderHelper($storage);
$signatureClient = $this->createStub(SignatureClient::class);
$stripeClient = $this->createStub(StripeClientService::class);
$em = $this->createStub(EntityManagerInterface::class);
$extension = new StripeExtension($uploaderHelper, $signatureClient, $stripeClient, $em);
$devis = $this->createStub(Devis::class);
$devis->method('getDevisLines')->willReturn(new \Doctrine\Common\Collections\ArrayCollection([]));
$devis->method('getDevisOptions')->willReturn(new \Doctrine\Common\Collections\ArrayCollection([]));
$total = $extension->totalQuoto($devis);
$this->assertIsFloat($total);
}
public function testTotalContrat(): void
{
$storage = $this->createStub(StorageInterface::class);
$uploaderHelper = new UploaderHelper($storage);
$signatureClient = $this->createStub(SignatureClient::class);
$stripeClient = $this->createStub(StripeClientService::class);
$em = $this->createStub(EntityManagerInterface::class);
$extension = new StripeExtension($uploaderHelper, $signatureClient, $stripeClient, $em);
$contrat = $this->createStub(Contrats::class);
$contrat->method('getContratsLines')->willReturn(new \Doctrine\Common\Collections\ArrayCollection([]));
$contrat->method('getContratsOptions')->willReturn(new \Doctrine\Common\Collections\ArrayCollection([]));
$contrat->method('getDateAt')->willReturn(new \DateTimeImmutable());
$contrat->method('getEndAt')->willReturn(new \DateTimeImmutable());
$total = $extension->totalContrat($contrat);
$this->assertIsFloat($total);
}
}

57
tests/Twig/ViteAssetExtensionTest.php Normal file
View File

@@ -0,0 +1,57 @@
<?php
namespace App\Tests\Twig;
use App\Twig\ViteAssetExtension;
use PHPUnit\Framework\TestCase;
use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;
class ViteAssetExtensionTest extends TestCase
{
public function testAssetDev(): void
{
$_ENV['VITE_LOAD'] = "0";
$cache = $this->createStub(CacheItemPoolInterface::class);
$extension = new class('/path/to/manifest.json', $cache, null) extends ViteAssetExtension {
protected function getNonce(): string {
return 'nonce123';
}
};
$html = $extension->asset('app.js');
$this->assertStringContainsString('http://localhost:5173', $html);
$this->assertStringContainsString('nonce="nonce123"', $html);
}
public function testAssetProd(): void
{
$_ENV['VITE_LOAD'] = "1";
$cache = $this->createStub(CacheItemPoolInterface::class);
$item = $this->createStub(CacheItemInterface::class);
$item->method('isHit')->willReturn(false);
$item->method('set')->willReturn($item);
$cache->method('getItem')->willReturn($item);
$manifestPath = sys_get_temp_dir() . '/manifest.json';
file_put_contents($manifestPath, json_encode([
'app.js' => ['file' => 'app.123.js', 'css' => ['app.123.css']]
]));
$extension = new class($manifestPath, $cache, null) extends ViteAssetExtension {
protected function getNonce(): string {
return 'nonce123';
}
};
$html = $extension->asset('app.js');
$this->assertStringContainsString('/build/app.123.js', $html);
$this->assertStringContainsString('/build/app.123.css', $html);
unlink($manifestPath);
}
}