mirror of
https://github.com/danog/Valinor.git
synced 2025-01-10 14:48:20 +01:00
69ad3f4777
The cache implementation that was previously injected in the mapper
builder must now be manually injected. This gives better control on when
the cache should be enabled, especially depending on which environment
the application is running.
The library provides a cache implementation out of the box, which saves
cache entries into the file system.
It is also possible to use any PSR-16 compliant implementation, as long
as it is capable of caching the entries handled by the library.
```php
$cache = new \CuyZ\Valinor\Cache\FileSystemCache('path/to/cache-dir');
(new \CuyZ\Valinor\MapperBuilder())
->withCache($cache)
->mapper()
->map(SomeClass::class, [/* … */]);
```
131 lines
3.6 KiB
PHP
131 lines
3.6 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace CuyZ\Valinor\Tests\Integration\Mapping\Attribute;
|
|
|
|
use Attribute;
|
|
use CuyZ\Valinor\Attribute\StaticMethodConstructor;
|
|
use CuyZ\Valinor\Definition\ClassDefinition;
|
|
use CuyZ\Valinor\Mapper\MappingError;
|
|
use CuyZ\Valinor\Mapper\Object\Exception\TooManyObjectBuilderFactoryAttributes;
|
|
use CuyZ\Valinor\Mapper\Object\Factory\ObjectBuilderFactory;
|
|
use CuyZ\Valinor\Mapper\Object\ObjectBuilder;
|
|
use CuyZ\Valinor\MapperBuilder;
|
|
use CuyZ\Valinor\Tests\Fake\Mapper\Object\FakeObjectBuilder;
|
|
use CuyZ\Valinor\Tests\Integration\IntegrationTest;
|
|
use RuntimeException;
|
|
|
|
final class ObjectBuilderStrategyMappingTest extends IntegrationTest
|
|
{
|
|
public function test_object_builder_attribute_is_used(): void
|
|
{
|
|
try {
|
|
$result = (new MapperBuilder())->mapper()->map(ObjectWithBuilderStrategyAttribute::class, [
|
|
'foo' => 'foo',
|
|
'bar' => 'bar',
|
|
]);
|
|
} catch (MappingError $error) {
|
|
$this->mappingFail($error);
|
|
}
|
|
|
|
self::assertSame('foo', $result->foo);
|
|
self::assertSame('bar', $result->bar);
|
|
self::assertTrue($result->staticConstructorCalled);
|
|
}
|
|
|
|
public function test_named_constructor_throwing_exception_is_caught_by_mapper(): void
|
|
{
|
|
try {
|
|
(new MapperBuilder())->mapper()->map(ObjectWithFailingBuilderStrategyAttribute::class, []);
|
|
} catch (MappingError $exception) {
|
|
$error = $exception->node()->messages()[0];
|
|
|
|
self::assertSame('some exception', (string)$error);
|
|
}
|
|
}
|
|
|
|
public function test_repeated_object_builder_factory_attributes_throws_exception(): void
|
|
{
|
|
$factoryClass = ObjectBuilderFactory::class;
|
|
$objectClass = ObjectWithSeveralBuilderStrategyAttributes::class;
|
|
|
|
$this->expectException(TooManyObjectBuilderFactoryAttributes::class);
|
|
$this->expectExceptionCode(1634044714);
|
|
$this->expectExceptionMessage("Only one attribute of type `$factoryClass` is allowed, class `$objectClass` contains 2.");
|
|
|
|
(new MapperBuilder())->mapper()->map($objectClass, 'foo');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @Annotation
|
|
*/
|
|
#[Attribute(Attribute::TARGET_CLASS)]
|
|
final class ForeignAttribute
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @Annotation
|
|
*/
|
|
#[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
|
|
final class ObjectBuilderStrategyAttribute implements ObjectBuilderFactory
|
|
{
|
|
public function for(ClassDefinition $class, $source): ObjectBuilder
|
|
{
|
|
return new FakeObjectBuilder();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @ForeignAttribute
|
|
* @StaticMethodConstructor("create")
|
|
*/
|
|
#[ForeignAttribute]
|
|
#[StaticMethodConstructor('create')]
|
|
final class ObjectWithBuilderStrategyAttribute
|
|
{
|
|
public bool $staticConstructorCalled = false;
|
|
|
|
public string $foo;
|
|
|
|
public string $bar;
|
|
|
|
private function __construct(string $foo, string $bar)
|
|
{
|
|
$this->foo = $foo;
|
|
$this->bar = $bar;
|
|
}
|
|
|
|
public static function create(string $foo, string $bar = 'optional value'): self
|
|
{
|
|
$instance = new self($foo, $bar);
|
|
$instance->staticConstructorCalled = true;
|
|
|
|
return $instance;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @StaticMethodConstructor("failingConstructor")
|
|
*/
|
|
#[StaticMethodConstructor('failingConstructor')]
|
|
final class ObjectWithFailingBuilderStrategyAttribute
|
|
{
|
|
public static function failingConstructor(): self
|
|
{
|
|
throw new RuntimeException('some exception');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @ObjectBuilderStrategyAttribute
|
|
* @ObjectBuilderStrategyAttribute
|
|
*/
|
|
#[ObjectBuilderStrategyAttribute]
|
|
#[ObjectBuilderStrategyAttribute]
|
|
final class ObjectWithSeveralBuilderStrategyAttributes
|
|
{
|
|
}
|