devsam/core
3
6
Fork 1
Code Issues 60 Pull Requests Releases 1 Wiki Activity

dep,refac: DTO를 composer 외부로 이동

Browse Source
This commit is contained in:
Hide_D
2022-08-05 23:43:38 +09:00
parent f8cd58bcb3
commit da27ae2bad
27 changed files with 90 additions and 1264 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/DTOTest.php
-468
View File
@@ -1,468 +0,0 @@
<?php
use sammo\DTO\Attr\Convert;
use sammo\DTO\Attr\DefaultValue;
use sammo\DTO\Attr\DefaultValueGenerator;
use sammo\DTO\Attr\Ignore;
use sammo\DTO\DTO;
use sammo\DTO\Attr\JsonString;
use sammo\DTO\Attr\NullIsUndefined;
use sammo\DTO\Attr\RawName;
use sammo\DTO\Converter\ArrayConverter;
use sammo\DTO\Converter\Converter;
use sammo\DTO\Converter\MapConverter;
use sammo\DTO\Converter\DateTimeConverter;
use sammo\Json;
class TypeA extends DTO
{
public function __construct(
public string $a,
public string $b,
public bool $c,
public ?int $d,
public float $e,
) {
}
}
class TypeBA extends DTO
{
public function __construct(
public int $ba1,
public int $ba2,
) {
}
}
class TypeB extends DTO
{
public function __construct(
public string $a,
public TypeBA $ba,
) {
}
}
class TypeC extends DTO
{
public function __construct(
public string $a,
#[JsonString]
public TypeBA $ba,
) {
}
}
enum EnumA
{
case A;
case B;
case cc;
}
class TypeD extends DTO
{
public function __construct(
public ?string $a,
public EnumA $b,
) {
}
}
class TypeE extends DTO
{
public function __construct(
public ?string $a,
#[NullIsUndefined]
public ?string $b,
) {
}
}
class ConverterDouble implements Converter
{
public function __construct(array $types, ...$args)
{
}
public function convertFrom(string|array|int|float|bool|null $raw, string $name): mixed
{
return $raw * 2;
}
public function convertTo(mixed $data): string|array|int|float|bool|null
{
return $data / 2;
}
}
class TypeF extends DTO
{
public function __construct(
public ?string $a,
#[Convert(ConverterDouble::class)]
public int $b,
) {
}
}
class TypeArr extends DTO
{
public function __construct(
public array $a,
public array $b,
) {
}
}
class TypeArrConverter extends DTO
{
public function __construct(
public array $a,
#[Convert(ArrayConverter::class, ['string'])]
public array $b,
) {
}
}
class TypeMap extends DTO
{
public function __construct(
public int $a,
#[Convert(MapConverter::class, ['null', 'string'])]
public array $b,
) {
}
}
class TypeNestedMap extends DTO
{
public function __construct(
public int $a,
#[Convert(MapConverter::class, ['null', TypeBA::class])]
public array $b,
) {
}
}
class TypeRawName extends DTO
{
public function __construct(
#[RawName('arg_name')]
public int $argName,
#[RawName('vID')]
public int $vID,
) {
}
}
class TypeDateTime extends DTO
{
public function __construct(
#[Convert(DateTimeConverter::class)]
public \DateTimeImmutable $a,
#[Convert(DateTimeConverter::class, 9, DateTimeConverter::YMD_HIS)]
public \DateTime $b,
#[Convert(DateTimeConverter::class, 8, DateTimeConverter::YMD_HISU)]
public \DateTimeImmutable|\DateTime $c,
#[Convert(DateTimeConverter::class)]
public \DateTimeInterface $d,
) {
}
}
function returnDateTime()
{
return new \DateTimeImmutable('2022-04-01 00:00:00');
}
class TypeDefaultValue extends DTO
{
public bool $g = true;
public function __construct(
public ?string $a,
#[DefaultValue(false)]
public bool $b,
public int $c,
#[DefaultValue([1,2,3])]
public array $e,
#[DefaultValueGenerator('returnDateTime')]
#[Convert(DateTimeConverter::class)]
public \DateTimeInterface $d,
public int $f = 111, //contstruct의 뒤에서 default 값이 설정될 경우에만
) {
}
}
class TypeIgnore extends DTO
{
#[Ignore]
public int $c = 100;
#[Ignore]
public $d;
#[Ignore]
public $e;
public function __construct(
public int $a,
public int $b,
) {
$this->d = $a * 2;
}
}
class DTOTest extends PHPUnit\Framework\TestCase
{
public function testBasic()
{
$rawType = [
'a' => '123',
'b' => 'aa',
'c' => false,
'd' => null,
'e' => 123.123,
];
$obj = TypeA::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testNested()
{
$rawType = [
'a' => '123',
'ba' => [
'ba1' => 3,
'ba2' => 4,
]
];
$obj = TypeB::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testNestedJson()
{
$x = Json::encode([
'ba1' => 3,
'ba2' => 4,
]);
$rawType = [
'a' => '123',
'ba' => $x
];
$obj = TypeC::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testEnum()
{
$rawType = [
'a' => '123',
'b' => 'B',
];
$obj = TypeD::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testNull()
{
$rawType = [
'a' => null,
];
$obj = TypeE::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testConverter()
{
$rawType = [
'a' => '123',
'b' => 123,
];
$obj = TypeF::fromArray($rawType);
$this->assertEquals($obj->b, 246);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testNullIsUndefined()
{
$rawType = [
'a' => null,
];
$obj = TypeE::fromArray($rawType);
$this->assertEquals($obj->a, null);
$this->assertEquals($obj->b, null);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testArr()
{
$rawType = [
'a' => [1, 2, 3],
'b' => [4, 5, 6],
];
$obj = TypeArr::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testArrConverterErr()
{
$this->expectException(Exception::class);
$rawType = [
'a' => [1, 2, 3],
'b' => [4, 5, 6],
];
$obj = TypeArrConverter::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testArrConverterErr2()
{
$this->expectException(Exception::class);
$rawType = [
'a' => [1, 2, 3],
'b' => [4 => 6, 5 => 2, 6 => 3],
];
$obj = TypeArrConverter::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testArrConverter()
{
$rawType = [
'a' => [1, 2, 3],
'b' => ['1', '2', '3'],
];
$obj = TypeArrConverter::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testMap()
{
$rawType = [
'a' => 1,
'b' => [
'1' => '1',
'2' => null,
'ba' => '3',
],
];
$obj = TypeMap::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testNestedMap()
{
$rawType = [
'a' => 1,
'b' => [
'aaa' => [
'ba1' => 1,
'ba2' => 2,
],
'xed' => null,
'ccc' => [
'ba1' => 3,
'ba2' => 4,
],
],
];
$obj = TypeNestedMap::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testRawName()
{
$rawType = [
'arg_name' => 1,
'vID' => 2,
];
$obj = TypeRawName::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
public function testDateTime()
{
$rawType = [
'a' => '2022-01-01 10:11:22',
'b' => '2022-02-01T12:34:56.1234+09:00',
'c' => '2022-03-01T00:00:00.1234+09:00',
'd' => '2022-04-01',
];
$testValue = [
'a' => '2022-01-01 10:11:22',
'b' => '2022-02-01 12:34:56',
'c' => '2022-02-28 23:00:00.123400',
'd' => '2022-04-01 00:00:00',
];
$obj = TypeDateTime::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($testValue, $testType);
}
public function testDefaultValue()
{
$rawType = [
'c' => 3,
];
$testValue = [
'g' => true,
'a' => null,
'b' => false,
'c' => 3,
'e' => [1, 2, 3],
'd' => '2022-04-01 00:00:00',
'f' => 111,
];
$obj = TypeDefaultValue::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($testValue, $testType);
}
public function testIgnore(){
$rawType = [
'a' => 1,
'b' => 2,
];
$obj = TypeIgnore::fromArray($rawType);
$testType = $obj->toArray();
$this->assertEquals($rawType, $testType);
}
}