feat: initial commit of camelia/orm
Attribute-mapped Active Record ORM for MariaDB/MySQL over PDO. - Attribute-driven metadata: TableName, PrimaryKey, AutoIncrement, Column, Guarded, Ignore, Required, Enum, Nullable, Length, Precision, Unique, UniqueGroup, Index, MaxLength. - Relationship mapping: BelongsTo, HasOne, HasMany, BelongsToMany with batched eager loading and a 3-level depth limit. - Orm entry point with fromArray, fromPdo, fromEnv and nested transactions. - Immutable Query with Cond operators and GroupCond grouping. - Repository read and write API, pagination, and typed exception hierarchy. - Declares PHP >=8.3; Mago and PHPStan pin the parser to 8.3. - MIT license.
This commit is contained in:
commit
66e93e3070
97 files changed
+12188
No files matched your search
@@ -0,0 +1,29 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture;
|
||||
|
||||
use Camelia\Orm\Attribute\AutoIncrement;
|
||||
use Camelia\Orm\Attribute\BelongsToMany;
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('articulos')]
|
||||
final class Articulo extends Model
|
||||
{
|
||||
#[PrimaryKey, AutoIncrement]
|
||||
public ?int $codigo = null;
|
||||
|
||||
public string $nombre = '';
|
||||
|
||||
/** @var array<int, Etiqueta> */
|
||||
#[BelongsToMany(
|
||||
related: Etiqueta::class,
|
||||
through: 'articulo_etiqueta',
|
||||
foreignPivotKey: 'articulo_codigo',
|
||||
relatedPivotKey: 'etiqueta_codigo',
|
||||
)]
|
||||
public array $etiquetas = [];
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture;
|
||||
|
||||
use Camelia\Orm\Attribute\AutoIncrement;
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('con_hooks')]
|
||||
final class ConHooks extends Model
|
||||
{
|
||||
#[PrimaryKey, AutoIncrement]
|
||||
public ?int $codigo = null;
|
||||
|
||||
public string $nombre = '';
|
||||
|
||||
public string $creadoPorHook = '';
|
||||
|
||||
protected function beforeInsert(): void
|
||||
{
|
||||
$this->creadoPorHook = 'insert';
|
||||
}
|
||||
|
||||
protected function beforeUpdate(): void
|
||||
{
|
||||
$this->creadoPorHook = 'update';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture;
|
||||
|
||||
use Camelia\Orm\Attribute\AutoIncrement;
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('detalles')]
|
||||
final class Detalle extends Model
|
||||
{
|
||||
#[PrimaryKey, AutoIncrement]
|
||||
public ?int $codigo = null;
|
||||
|
||||
public int $facturaCodigo = 0;
|
||||
|
||||
public string $concepto = '';
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture;
|
||||
|
||||
use Camelia\Orm\Attribute\AutoIncrement;
|
||||
use Camelia\Orm\Attribute\BelongsToMany;
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
/**
|
||||
* Chain fixture used to prove nested eager loading:
|
||||
* Articulo -> Etiqueta -> Factura -> Usuario.
|
||||
*/
|
||||
#[TableName('etiquetas')]
|
||||
final class Etiqueta extends Model
|
||||
{
|
||||
#[PrimaryKey]
|
||||
#[AutoIncrement]
|
||||
public ?int $codigo = null;
|
||||
|
||||
public string $nombre = '';
|
||||
|
||||
/** @var array<int, Factura> */
|
||||
#[BelongsToMany(
|
||||
related: Factura::class,
|
||||
through: 'etiqueta_factura',
|
||||
foreignPivotKey: 'etiqueta_codigo',
|
||||
relatedPivotKey: 'factura_codigo',
|
||||
)]
|
||||
public array $facturas = [];
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture;
|
||||
|
||||
use Camelia\Orm\Attribute\AutoIncrement;
|
||||
use Camelia\Orm\Attribute\BelongsTo;
|
||||
use Camelia\Orm\Attribute\Column;
|
||||
use Camelia\Orm\Attribute\HasMany;
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('facturas')]
|
||||
final class Factura extends Model
|
||||
{
|
||||
#[PrimaryKey, AutoIncrement]
|
||||
public ?int $codigo = null;
|
||||
|
||||
public int $usuarioCodigo = 0;
|
||||
|
||||
#[Column('importe_total')]
|
||||
public float $total = 0.0;
|
||||
|
||||
#[BelongsTo(Usuario::class, foreignKey: 'usuarioCodigo')]
|
||||
public ?Usuario $usuario = null;
|
||||
|
||||
/** @var array<int, Detalle> */
|
||||
#[HasMany(Detalle::class, foreignKey: 'facturaCodigo')]
|
||||
public array $detalles = [];
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture\Invalid;
|
||||
|
||||
use Camelia\Orm\Attribute\Column;
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('columna_duplicada')]
|
||||
final class ColumnaDuplicada extends Model
|
||||
{
|
||||
#[PrimaryKey]
|
||||
public ?int $codigo = null;
|
||||
|
||||
public string $nombre = '';
|
||||
|
||||
#[Column('nombre')]
|
||||
public string $nombreAlternativo = '';
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture\Invalid;
|
||||
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('dos_pk')]
|
||||
final class DosPrimaryKeys extends Model
|
||||
{
|
||||
#[PrimaryKey]
|
||||
public ?int $codigo = null;
|
||||
|
||||
#[PrimaryKey]
|
||||
public ?int $otro = null;
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture\Invalid;
|
||||
|
||||
use Camelia\Orm\Attribute\BelongsTo;
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
|
||||
#[TableName('relacion_no_nulable')]
|
||||
final class RelacionNoNulable extends Model
|
||||
{
|
||||
#[PrimaryKey]
|
||||
public ?int $codigo = null;
|
||||
|
||||
#[BelongsTo(Usuario::class, foreignKey: 'codigo')]
|
||||
public Usuario $usuario;
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture\Invalid;
|
||||
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('sin_pk')]
|
||||
final class SinPrimaryKey extends Model
|
||||
{
|
||||
public string $nombre = '';
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture\Invalid;
|
||||
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
final class SinTableName extends Model
|
||||
{
|
||||
#[PrimaryKey]
|
||||
public ?int $codigo = null;
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture\Invalid;
|
||||
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('sin_tipo')]
|
||||
final class SinTipo extends Model
|
||||
{
|
||||
#[PrimaryKey]
|
||||
public ?int $codigo = null;
|
||||
|
||||
public $nombre;
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Fixture;
|
||||
|
||||
use Camelia\Orm\Attribute\AutoIncrement;
|
||||
use Camelia\Orm\Attribute\Guarded;
|
||||
use Camelia\Orm\Attribute\MaxLength;
|
||||
use Camelia\Orm\Attribute\PrimaryKey;
|
||||
use Camelia\Orm\Attribute\Required;
|
||||
use Camelia\Orm\Attribute\TableName;
|
||||
use Camelia\Orm\Model;
|
||||
|
||||
#[TableName('usuarios')]
|
||||
final class Usuario extends Model
|
||||
{
|
||||
#[PrimaryKey, AutoIncrement]
|
||||
public ?int $codigo = null;
|
||||
|
||||
public string $nombre = '';
|
||||
|
||||
public string $correo = '';
|
||||
|
||||
#[Guarded]
|
||||
public string $passwordHash = '';
|
||||
|
||||
public bool $activo = true;
|
||||
|
||||
public ?string $apodo = null;
|
||||
|
||||
#[Required]
|
||||
#[MaxLength(10)]
|
||||
public string $clave = '';
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Support;
|
||||
|
||||
use Camelia\Orm\Connection\Connection;
|
||||
|
||||
/**
|
||||
* Records every statement instead of touching a database.
|
||||
*/
|
||||
final class FakeConnection implements Connection
|
||||
{
|
||||
/** @var list<array{sql: string, params: list<mixed>}> */
|
||||
public array $executed = [];
|
||||
|
||||
/** @var list<array{sql: string, params: list<mixed>}> */
|
||||
public array $selected = [];
|
||||
|
||||
/** @var list<array<string, mixed>> rows returned by select() */
|
||||
public array $rows = [];
|
||||
|
||||
/** @var list<list<array<string, mixed>>> sequential responses; when set, consumed before $rows */
|
||||
public array $rowBatches = [];
|
||||
|
||||
/** @var list<mixed> values returned in order by scalar() */
|
||||
public array $scalars = [];
|
||||
|
||||
public string $lastInsertId = '1';
|
||||
|
||||
public int $affected = 1;
|
||||
|
||||
public int $beginCount = 0;
|
||||
|
||||
public int $commitCount = 0;
|
||||
|
||||
public int $rollBackCount = 0;
|
||||
|
||||
private bool $inTransaction = false;
|
||||
|
||||
public function execute(string $sql, array $params = []): int
|
||||
{
|
||||
$this->executed[] = ['sql' => $sql, 'params' => $params];
|
||||
|
||||
return $this->affected;
|
||||
}
|
||||
|
||||
public function select(string $sql, array $params = []): array
|
||||
{
|
||||
$this->selected[] = ['sql' => $sql, 'params' => $params];
|
||||
|
||||
if ($this->rowBatches !== []) {
|
||||
return array_shift($this->rowBatches);
|
||||
}
|
||||
|
||||
return $this->rows;
|
||||
}
|
||||
|
||||
public function scalar(string $sql, array $params = []): mixed
|
||||
{
|
||||
$this->selected[] = ['sql' => $sql, 'params' => $params];
|
||||
|
||||
return $this->scalars === [] ? null : array_shift($this->scalars);
|
||||
}
|
||||
|
||||
public function lastInsertId(): string
|
||||
{
|
||||
return $this->lastInsertId;
|
||||
}
|
||||
|
||||
public function begin(): void
|
||||
{
|
||||
$this->beginCount++;
|
||||
$this->inTransaction = true;
|
||||
}
|
||||
|
||||
public function commit(): void
|
||||
{
|
||||
$this->commitCount++;
|
||||
$this->inTransaction = false;
|
||||
}
|
||||
|
||||
public function rollBack(): void
|
||||
{
|
||||
$this->rollBackCount++;
|
||||
$this->inTransaction = false;
|
||||
}
|
||||
|
||||
public function inTransaction(): bool
|
||||
{
|
||||
return $this->inTransaction;
|
||||
}
|
||||
|
||||
public function driver(): string
|
||||
{
|
||||
return 'fake';
|
||||
}
|
||||
|
||||
public function lastSql(): string
|
||||
{
|
||||
if ($this->executed === []) {
|
||||
return '';
|
||||
}
|
||||
|
||||
return $this->executed[count($this->executed) - 1]['sql'];
|
||||
}
|
||||
|
||||
/** @return list<mixed> */
|
||||
public function lastParams(): array
|
||||
{
|
||||
$entries = $this->selected === [] ? $this->executed : $this->selected;
|
||||
|
||||
if ($entries === []) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return $entries[count($entries) - 1]['params'];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,205 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit;
|
||||
|
||||
use Camelia\Orm\Exception\MetadataException;
|
||||
use Camelia\Orm\Repository;
|
||||
use Camelia\Orm\Tests\Fixture\Articulo;
|
||||
use Camelia\Orm\Tests\Fixture\Detalle;
|
||||
use Camelia\Orm\Tests\Fixture\Etiqueta;
|
||||
use Camelia\Orm\Tests\Fixture\Factura;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use Camelia\Orm\Tests\Support\FakeConnection;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class EagerLoadingTest extends TestCase
|
||||
{
|
||||
private FakeConnection $connection;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$this->connection = new FakeConnection();
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_loads_belongs_to_in_one_batch_query(): void
|
||||
{
|
||||
$this->connection->rowBatches = [
|
||||
[$this->facturaRow(1, 7), $this->facturaRow(2, 8)],
|
||||
[$this->usuarioRow(7, 'Ana'), $this->usuarioRow(8, 'Bea')],
|
||||
];
|
||||
|
||||
$facturas = $this->repository(Factura::class)->find(with: ['usuario']);
|
||||
|
||||
self::assertCount(2, $facturas);
|
||||
$primera = $facturas[0];
|
||||
self::assertInstanceOf(Factura::class, $primera);
|
||||
self::assertInstanceOf(Usuario::class, $primera->usuario);
|
||||
self::assertSame('Ana', $primera->usuario->nombre);
|
||||
self::assertCount(2, $this->connection->selected);
|
||||
self::assertStringContainsString('IN (?, ?)', $this->connection->selected[1]['sql']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_loads_has_many_grouped_by_parent(): void
|
||||
{
|
||||
$this->connection->rowBatches = [
|
||||
[$this->facturaRow(1, 7)],
|
||||
[
|
||||
['codigo' => '10', 'factura_codigo' => '1', 'concepto' => 'A'],
|
||||
['codigo' => '11', 'factura_codigo' => '1', 'concepto' => 'B'],
|
||||
],
|
||||
];
|
||||
|
||||
$facturas = $this->repository(Factura::class)->find(with: ['detalles']);
|
||||
$factura = $facturas[0];
|
||||
|
||||
self::assertInstanceOf(Factura::class, $factura);
|
||||
self::assertCount(2, $factura->detalles);
|
||||
$detalle = $factura->detalles[0];
|
||||
self::assertInstanceOf(Detalle::class, $detalle);
|
||||
self::assertSame('A', $detalle->concepto);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_loads_belongs_to_many_through_the_pivot(): void
|
||||
{
|
||||
$this->connection->rowBatches = [
|
||||
[['codigo' => '1', 'nombre' => 'Articulo']],
|
||||
[
|
||||
['pivot_owner' => '1', 'pivot_related' => '5'],
|
||||
['pivot_owner' => '1', 'pivot_related' => '6'],
|
||||
],
|
||||
[
|
||||
['codigo' => '5', 'nombre' => 'rojo'],
|
||||
['codigo' => '6', 'nombre' => 'verde'],
|
||||
],
|
||||
];
|
||||
|
||||
$articulos = $this->repository(Articulo::class)->find(with: ['etiquetas']);
|
||||
$articulo = $articulos[0];
|
||||
|
||||
self::assertInstanceOf(Articulo::class, $articulo);
|
||||
self::assertCount(2, $articulo->etiquetas);
|
||||
$etiqueta = $articulo->etiquetas[0];
|
||||
self::assertInstanceOf(Etiqueta::class, $etiqueta);
|
||||
self::assertSame('rojo', $etiqueta->nombre);
|
||||
self::assertStringContainsString(
|
||||
'`articulo_etiqueta`',
|
||||
$this->connection->selected[1]['sql'],
|
||||
);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_leaves_belongs_to_null_when_the_row_is_missing(): void
|
||||
{
|
||||
$this->connection->rowBatches = [
|
||||
[$this->facturaRow(1, 99)],
|
||||
[],
|
||||
];
|
||||
|
||||
$facturas = $this->repository(Factura::class)->find(with: ['usuario']);
|
||||
$factura = $facturas[0];
|
||||
|
||||
self::assertInstanceOf(Factura::class, $factura);
|
||||
self::assertNull($factura->usuario);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_refuses_an_unknown_relation(): void
|
||||
{
|
||||
$this->connection->rowBatches = [];
|
||||
|
||||
$this->expectException(MetadataException::class);
|
||||
|
||||
$this->repository(Factura::class)->find(with: ['usuario.inexistente']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_accepts_deeply_nested_paths_up_to_the_limit(): void
|
||||
{
|
||||
$this->connection->rowBatches = [
|
||||
[['codigo' => '1', 'nombre' => 'Articulo']],
|
||||
[['pivot_owner' => '1', 'pivot_related' => '5']],
|
||||
[['codigo' => '5', 'nombre' => 'rojo']],
|
||||
[$this->facturaRow(1, 7)],
|
||||
[$this->usuarioRow(7, 'Ana')],
|
||||
];
|
||||
|
||||
$articulos = $this->repository(Articulo::class)->find(with: ['etiquetas.facturas.usuario']);
|
||||
|
||||
self::assertCount(1, $articulos);
|
||||
$articulo = $articulos[0];
|
||||
self::assertInstanceOf(Articulo::class, $articulo);
|
||||
self::assertCount(1, $articulo->etiquetas);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_refuses_an_unknown_nested_relation(): void
|
||||
{
|
||||
$this->connection->rowBatches = [
|
||||
[$this->facturaRow(1, 7)],
|
||||
[$this->usuarioRow(7, 'Ana')],
|
||||
];
|
||||
|
||||
$this->expectException(MetadataException::class);
|
||||
|
||||
$this->repository(Factura::class)->find(with: ['usuario.inexistente']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_refreshes_relations_on_a_hydrated_model(): void
|
||||
{
|
||||
$this->connection->rowBatches = [
|
||||
[$this->usuarioRow(7, 'Ana')],
|
||||
];
|
||||
|
||||
$factura = new Factura();
|
||||
$factura->codigo = 1;
|
||||
$factura->usuarioCodigo = 7;
|
||||
|
||||
$this->repository(Factura::class)->refreshRelations($factura, ['usuario']);
|
||||
|
||||
self::assertInstanceOf(Usuario::class, $factura->usuario);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param class-string<\Camelia\Orm\Model> $class
|
||||
* @return Repository<\Camelia\Orm\Model>
|
||||
*/
|
||||
private function repository(string $class): Repository
|
||||
{
|
||||
return new Repository($this->connection, $class);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
private function facturaRow(int $codigo, int $usuarioCodigo): array
|
||||
{
|
||||
return [
|
||||
'codigo' => (string) $codigo,
|
||||
'usuario_codigo' => (string) $usuarioCodigo,
|
||||
'importe_total' => '10.5',
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
private function usuarioRow(int $codigo, string $nombre): array
|
||||
{
|
||||
return [
|
||||
'codigo' => (string) $codigo,
|
||||
'nombre' => $nombre,
|
||||
'correo' => 'a@x',
|
||||
'password_hash' => '',
|
||||
'activo' => '1',
|
||||
'apodo' => null,
|
||||
'clave' => '',
|
||||
];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,139 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit\Metadata;
|
||||
|
||||
use Camelia\Orm\Exception\MetadataException;
|
||||
use Camelia\Orm\Metadata\MetadataFactory;
|
||||
use Camelia\Orm\Tests\Fixture\Articulo;
|
||||
use Camelia\Orm\Tests\Fixture\Factura;
|
||||
use Camelia\Orm\Tests\Fixture\Invalid\ColumnaDuplicada;
|
||||
use Camelia\Orm\Tests\Fixture\Invalid\DosPrimaryKeys;
|
||||
use Camelia\Orm\Tests\Fixture\Invalid\RelacionNoNulable;
|
||||
use Camelia\Orm\Tests\Fixture\Invalid\SinPrimaryKey;
|
||||
use Camelia\Orm\Tests\Fixture\Invalid\SinTableName;
|
||||
use Camelia\Orm\Tests\Fixture\Invalid\SinTipo;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class MetadataFactoryTest extends TestCase
|
||||
{
|
||||
#[Test]
|
||||
public function it_reads_table_and_primary_key(): void
|
||||
{
|
||||
$metadata = (new MetadataFactory())->forClass(Usuario::class);
|
||||
|
||||
self::assertSame('usuarios', $metadata->table());
|
||||
self::assertSame('codigo', $metadata->primaryKey());
|
||||
self::assertSame('codigo', $metadata->primaryKeyColumn());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_converts_property_names_to_columns(): void
|
||||
{
|
||||
$metadata = (new MetadataFactory())->forClass(Usuario::class);
|
||||
|
||||
self::assertSame('password_hash', $metadata->column('passwordHash'));
|
||||
self::assertSame('passwordHash', $metadata->property('password_hash'));
|
||||
self::assertNull($metadata->property('inexistente'));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_honours_an_explicit_column_name(): void
|
||||
{
|
||||
$metadata = (new MetadataFactory())->forClass(Factura::class);
|
||||
|
||||
self::assertSame('importe_total', $metadata->column('total'));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_excludes_relations_from_writable_columns(): void
|
||||
{
|
||||
$metadata = (new MetadataFactory())->forClass(Factura::class);
|
||||
|
||||
self::assertSame(['usuarioCodigo', 'total'], $metadata->writable());
|
||||
self::assertCount(2, $metadata->relations());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_resolves_belongs_to_metadata(): void
|
||||
{
|
||||
$metadata = (new MetadataFactory())->forClass(Factura::class);
|
||||
$relation = $metadata->properties()['usuario']->relation;
|
||||
|
||||
self::assertNotNull($relation);
|
||||
self::assertSame('belongsTo', $relation->kind);
|
||||
self::assertSame(Usuario::class, $relation->relatedClass);
|
||||
self::assertSame('usuarioCodigo', $relation->foreignKey);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_resolves_belongs_to_many_pivot_metadata(): void
|
||||
{
|
||||
$metadata = (new MetadataFactory())->forClass(Articulo::class);
|
||||
$relation = $metadata->properties()['etiquetas']->relation;
|
||||
|
||||
self::assertNotNull($relation);
|
||||
self::assertSame('belongsToMany', $relation->kind);
|
||||
self::assertSame('articulo_etiqueta', $relation->through);
|
||||
self::assertSame('articulo_codigo', $relation->foreignPivotKey);
|
||||
self::assertSame('etiqueta_codigo', $relation->relatedPivotKey);
|
||||
self::assertTrue($relation->isToMany());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_a_model_without_table_name(): void
|
||||
{
|
||||
$this->expectException(MetadataException::class);
|
||||
$this->expectExceptionMessage('[M2]');
|
||||
|
||||
(new MetadataFactory())->forClass(SinTableName::class);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_a_model_without_primary_key(): void
|
||||
{
|
||||
$this->expectException(MetadataException::class);
|
||||
$this->expectExceptionMessage('[M3]');
|
||||
|
||||
(new MetadataFactory())->forClass(SinPrimaryKey::class);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_a_model_with_two_primary_keys(): void
|
||||
{
|
||||
$this->expectException(MetadataException::class);
|
||||
$this->expectExceptionMessage('[M3]');
|
||||
|
||||
(new MetadataFactory())->forClass(DosPrimaryKeys::class);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_an_untyped_property(): void
|
||||
{
|
||||
$this->expectException(MetadataException::class);
|
||||
$this->expectExceptionMessage('[M4]');
|
||||
|
||||
(new MetadataFactory())->forClass(SinTipo::class);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_duplicate_columns(): void
|
||||
{
|
||||
$this->expectException(MetadataException::class);
|
||||
$this->expectExceptionMessage('[M7]');
|
||||
|
||||
(new MetadataFactory())->forClass(ColumnaDuplicada::class);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_a_non_nullable_relation(): void
|
||||
{
|
||||
$this->expectException(MetadataException::class);
|
||||
$this->expectExceptionMessage('[M5]');
|
||||
|
||||
(new MetadataFactory())->forClass(RelacionNoNulable::class);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit;
|
||||
|
||||
use Camelia\Orm\Tests\Fixture\Factura;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class ModelTest extends TestCase
|
||||
{
|
||||
#[Test]
|
||||
public function it_initializes_neutral_values(): void
|
||||
{
|
||||
$usuario = new Usuario();
|
||||
|
||||
self::assertNull($usuario->codigo);
|
||||
self::assertSame('', $usuario->nombre);
|
||||
self::assertTrue($usuario->activo);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_preserves_declared_defaults(): void
|
||||
{
|
||||
$factura = new Factura();
|
||||
|
||||
self::assertSame(0.0, $factura->total);
|
||||
self::assertSame([], $factura->detalles);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_hydrates_by_property_name(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['nombre' => 'Ana', 'activo' => false]);
|
||||
|
||||
self::assertSame('Ana', $usuario->nombre);
|
||||
self::assertFalse($usuario->activo);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_hydrates_by_column_name(): void
|
||||
{
|
||||
$factura = (new Factura())->hydrate(['importe_total' => '12.5']);
|
||||
|
||||
self::assertSame(12.5, $factura->total);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_prefers_the_property_when_both_forms_are_present(): void
|
||||
{
|
||||
$factura = (new Factura())->hydrate(['total' => 1.0, 'importe_total' => 2.0]);
|
||||
|
||||
self::assertSame(1.0, $factura->total);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_skips_guarded_properties(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['passwordHash' => 'secreto']);
|
||||
|
||||
self::assertSame('', $usuario->passwordHash);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_guarded_properties_in_strict_mode(): void
|
||||
{
|
||||
$this->expectException(\InvalidArgumentException::class);
|
||||
|
||||
(new Usuario())->hydrateStrict(['passwordHash' => 'secreto']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_ignores_unknown_keys(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['inexistente' => 1, 'nombre' => 'Ana']);
|
||||
|
||||
self::assertSame('Ana', $usuario->nombre);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_never_hydrates_the_primary_key(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['codigo' => 99]);
|
||||
|
||||
self::assertNull($usuario->codigo);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_casts_and_refuses_uncastable_values(): void
|
||||
{
|
||||
$this->expectException(\InvalidArgumentException::class);
|
||||
|
||||
(new Usuario())->hydrate(['activo' => 'no-es-bool']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_serializes_writable_columns_by_column_name(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['nombre' => 'Ana']);
|
||||
$array = $usuario->toArray();
|
||||
|
||||
self::assertSame('Ana', $array['nombre']);
|
||||
self::assertArrayHasKey('password_hash', $array);
|
||||
self::assertArrayNotHasKey('codigo', $array);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_serializes_json(): void
|
||||
{
|
||||
$json = (new Usuario())->hydrate(['nombre' => 'Ana'])->toJson();
|
||||
$decoded = json_decode($json, true);
|
||||
|
||||
self::assertIsArray($decoded);
|
||||
self::assertSame('Ana', $decoded['nombre']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_validates_required_and_max_length(): void
|
||||
{
|
||||
$usuario = new Usuario();
|
||||
$errors = $usuario->validate();
|
||||
|
||||
self::assertArrayHasKey('clave', $errors);
|
||||
self::assertStringContainsString('requerido', $errors['clave'][0]);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_reports_a_too_long_value(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['clave' => 'supercalifragilistico']);
|
||||
|
||||
self::assertStringContainsString('10', $usuario->validate()['clave'][0]);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_is_valid_when_no_rule_fails(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['clave' => 'abc']);
|
||||
|
||||
self::assertTrue($usuario->isValid());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_replicates_without_the_primary_key(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['nombre' => 'Ana']);
|
||||
$usuario->codigo = 5;
|
||||
|
||||
$copy = $usuario->replicate();
|
||||
|
||||
self::assertNull($copy->codigo);
|
||||
self::assertSame('Ana', $copy->nombre);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_tracks_partial_state(): void
|
||||
{
|
||||
$usuario = new Usuario();
|
||||
|
||||
self::assertFalse($usuario->isPartial());
|
||||
$usuario->markPartial();
|
||||
self::assertTrue($usuario->isPartial());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit;
|
||||
|
||||
use Camelia\Orm\Orm;
|
||||
use Camelia\Orm\Repository;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use Camelia\Orm\Tests\Support\FakeConnection;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class OrmTest extends TestCase
|
||||
{
|
||||
#[Test]
|
||||
public function it_returns_a_repository_for_a_model(): void
|
||||
{
|
||||
$orm = Orm::fromConnection(new FakeConnection());
|
||||
|
||||
self::assertInstanceOf(Repository::class, $orm->repository(Usuario::class));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_reuses_the_same_repository_instance(): void
|
||||
{
|
||||
$orm = Orm::fromConnection(new FakeConnection());
|
||||
|
||||
self::assertSame($orm->repository(Usuario::class), $orm->repository(Usuario::class));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_commits_a_successful_transaction(): void
|
||||
{
|
||||
$connection = new FakeConnection();
|
||||
$orm = Orm::fromConnection($connection);
|
||||
|
||||
$result = $orm->transaction(static fn(): string => 'ok');
|
||||
|
||||
self::assertSame('ok', $result);
|
||||
self::assertSame(1, $connection->commitCount);
|
||||
self::assertSame(0, $connection->rollBackCount);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rolls_back_and_rethrows(): void
|
||||
{
|
||||
$connection = new FakeConnection();
|
||||
$orm = Orm::fromConnection($connection);
|
||||
|
||||
$this->expectException(\RuntimeException::class);
|
||||
|
||||
try {
|
||||
$orm->transaction(static function (): void {
|
||||
throw new \RuntimeException('boom');
|
||||
});
|
||||
} finally {
|
||||
self::assertSame(1, $connection->rollBackCount);
|
||||
self::assertSame(0, $connection->commitCount);
|
||||
}
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_exposes_the_connection(): void
|
||||
{
|
||||
$connection = new FakeConnection();
|
||||
|
||||
self::assertSame($connection, Orm::fromConnection($connection)->connection());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit;
|
||||
|
||||
use Camelia\Orm\Pagination\Page;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class PageTest extends TestCase
|
||||
{
|
||||
#[Test]
|
||||
public function it_computes_total_pages_as_int(): void
|
||||
{
|
||||
$page = Page::of([], 1, 10, 25);
|
||||
|
||||
self::assertSame(3, $page->totalPages);
|
||||
self::assertIsInt($page->totalPages);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_reports_next_and_prev(): void
|
||||
{
|
||||
$page = Page::of([], 2, 10, 25);
|
||||
|
||||
self::assertTrue($page->hasNext());
|
||||
self::assertTrue($page->hasPrev());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_does_not_report_next_on_the_last_page(): void
|
||||
{
|
||||
$page = Page::of([], 3, 10, 25);
|
||||
|
||||
self::assertFalse($page->hasNext());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_clamps_invalid_pagination_inputs(): void
|
||||
{
|
||||
$page = Page::of([], 0, 5000, 10);
|
||||
|
||||
self::assertSame(1, $page->page);
|
||||
self::assertSame(Page::MAX_PER_PAGE, $page->perPage);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_serializes_in_snake_case(): void
|
||||
{
|
||||
$array = Page::of([], 1, 10, 3)->toArray();
|
||||
|
||||
self::assertSame(
|
||||
['items', 'page', 'per_page', 'total', 'total_pages', 'has_next', 'has_prev'],
|
||||
array_keys($array),
|
||||
);
|
||||
self::assertSame(1, $array['total_pages']);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit;
|
||||
|
||||
use Camelia\Orm\Exception\PartialModelException;
|
||||
use Camelia\Orm\Exception\ValidationException;
|
||||
use Camelia\Orm\Persistence\AuditListener;
|
||||
use Camelia\Orm\Persistence\Persister;
|
||||
use Camelia\Orm\Query\MySqlDialect;
|
||||
use Camelia\Orm\Query\QueryBuilder;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use Camelia\Orm\Tests\Support\FakeConnection;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class PersisterTest extends TestCase
|
||||
{
|
||||
private FakeConnection $connection;
|
||||
|
||||
private Persister $persister;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$this->connection = new FakeConnection();
|
||||
$this->persister = new Persister($this->connection, new QueryBuilder(new MySqlDialect()));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_inserts_and_assigns_the_generated_key(): void
|
||||
{
|
||||
$this->connection->lastInsertId = '42';
|
||||
$usuario = (new Usuario())->hydrate(['nombre' => 'Ana', 'clave' => 'abc']);
|
||||
|
||||
$key = $this->persister->insert($usuario);
|
||||
|
||||
self::assertSame(42, $key);
|
||||
self::assertSame(42, $usuario->codigo);
|
||||
self::assertStringStartsWith('INSERT INTO `usuarios`', $this->connection->lastSql());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_only_writes_writable_columns(): void
|
||||
{
|
||||
$this->connection->lastInsertId = '1';
|
||||
$usuario = (new Usuario())->hydrate(['nombre' => 'Ana', 'clave' => 'abc']);
|
||||
|
||||
$this->persister->insert($usuario);
|
||||
|
||||
$sql = $this->connection->lastSql();
|
||||
|
||||
self::assertStringNotContainsString('`codigo`', $sql);
|
||||
self::assertStringContainsString('`password_hash`', $sql);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_saves_as_update_when_the_key_is_present(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['nombre' => 'Ana', 'clave' => 'abc']);
|
||||
$usuario->codigo = 9;
|
||||
|
||||
$this->persister->save($usuario);
|
||||
|
||||
self::assertStringStartsWith('UPDATE `usuarios`', $this->connection->lastSql());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_saves_as_insert_when_the_key_is_absent(): void
|
||||
{
|
||||
$this->connection->lastInsertId = '3';
|
||||
$usuario = (new Usuario())->hydrate(['nombre' => 'Ana', 'clave' => 'abc']);
|
||||
|
||||
$this->persister->save($usuario);
|
||||
|
||||
self::assertStringStartsWith('INSERT INTO `usuarios`', $this->connection->lastSql());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_refuses_an_invalid_model(): void
|
||||
{
|
||||
$this->expectException(ValidationException::class);
|
||||
|
||||
$this->persister->insert((new Usuario())->hydrate(['nombre' => 'Ana']));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_refuses_to_write_a_partial_model(): void
|
||||
{
|
||||
$usuario = (new Usuario())->hydrate(['nombre' => 'Ana', 'clave' => 'abc']);
|
||||
$usuario->codigo = 1;
|
||||
$usuario->markPartial();
|
||||
|
||||
$this->expectException(PartialModelException::class);
|
||||
|
||||
$this->persister->update($usuario);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_patches_only_the_given_columns(): void
|
||||
{
|
||||
$this->persister->patch(new Usuario(), 5, ['nombre' => 'Bea']);
|
||||
|
||||
self::assertSame(
|
||||
'UPDATE `usuarios` SET `nombre` = ? WHERE `codigo` = ?',
|
||||
$this->connection->lastSql(),
|
||||
);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_removes_by_primary_key(): void
|
||||
{
|
||||
$removed = $this->persister->remove(new Usuario(), 5);
|
||||
|
||||
self::assertTrue($removed);
|
||||
self::assertSame('DELETE FROM `usuarios` WHERE `codigo` = ?', $this->connection->lastSql());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_returns_false_when_nothing_was_removed(): void
|
||||
{
|
||||
$this->connection->affected = 0;
|
||||
|
||||
self::assertFalse($this->persister->remove(new Usuario(), 5));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_notifies_the_audit_listener(): void
|
||||
{
|
||||
$listener = new class() implements AuditListener {
|
||||
/** @var list<array{action: string, pk: int|string}> */
|
||||
public array $calls = [];
|
||||
|
||||
public function onWrite(
|
||||
string $table,
|
||||
int|string $pk,
|
||||
string $action,
|
||||
?array $before,
|
||||
array $after,
|
||||
): void {
|
||||
$this->calls[] = ['action' => $action, 'pk' => $pk];
|
||||
}
|
||||
};
|
||||
|
||||
$this->connection->lastInsertId = '7';
|
||||
$persister = new Persister(
|
||||
$this->connection,
|
||||
new QueryBuilder(new MySqlDialect()),
|
||||
$listener,
|
||||
);
|
||||
|
||||
$persister->insert((new Usuario())->hydrate(['nombre' => 'Ana', 'clave' => 'abc']));
|
||||
|
||||
self::assertSame([['action' => 'insert', 'pk' => 7]], $listener->calls);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_invokes_the_before_insert_hook(): void
|
||||
{
|
||||
$model = new \Camelia\Orm\Tests\Fixture\ConHooks();
|
||||
|
||||
$this->persister->insert($model);
|
||||
|
||||
self::assertSame('insert', $model->creadoPorHook);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_invokes_the_before_update_hook(): void
|
||||
{
|
||||
$model = new \Camelia\Orm\Tests\Fixture\ConHooks();
|
||||
$model->codigo = 3;
|
||||
|
||||
$this->persister->update($model);
|
||||
|
||||
self::assertSame('update', $model->creadoPorHook);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit\Query;
|
||||
|
||||
use Camelia\Orm\Exception\CriteriaException;
|
||||
use Camelia\Orm\Metadata\MetadataFactory;
|
||||
use Camelia\Orm\Query\Cond;
|
||||
use Camelia\Orm\Query\CriteriaCompiler;
|
||||
use Camelia\Orm\Query\MySqlDialect;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class CriteriaCompilerTest extends TestCase
|
||||
{
|
||||
private CriteriaCompiler $compiler;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$this->compiler = new CriteriaCompiler(new MySqlDialect());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_returns_an_empty_fragment_without_criteria(): void
|
||||
{
|
||||
[$sql, $params] = $this->compiler->compile($this->metadata(), []);
|
||||
|
||||
self::assertSame('', $sql);
|
||||
self::assertSame([], $params);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_scalar_equality(): void
|
||||
{
|
||||
[$sql, $params] = $this->compiler->compile($this->metadata(), ['activo' => true]);
|
||||
|
||||
self::assertSame('`activo` = ?', $sql);
|
||||
self::assertSame([true], $params);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_accepts_column_names_as_keys(): void
|
||||
{
|
||||
[$sql] = $this->compiler->compile($this->metadata(), ['password_hash' => 'x']);
|
||||
|
||||
self::assertSame('`password_hash` = ?', $sql);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_arrays_as_in(): void
|
||||
{
|
||||
[$sql, $params] = $this->compiler->compile($this->metadata(), ['codigo' => [1, 2]]);
|
||||
|
||||
self::assertSame('`codigo` IN (?, ?)', $sql);
|
||||
self::assertSame([1, 2], $params);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_an_empty_array_as_always_false(): void
|
||||
{
|
||||
[$sql, $params] = $this->compiler->compile($this->metadata(), ['codigo' => []]);
|
||||
|
||||
self::assertSame('1 = 0', $sql);
|
||||
self::assertSame([], $params);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_null_as_is_null(): void
|
||||
{
|
||||
[$sql, $params] = $this->compiler->compile($this->metadata(), ['apodo' => null]);
|
||||
|
||||
self::assertSame('`apodo` IS NULL', $sql);
|
||||
self::assertSame([], $params);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_combines_criteria_with_and(): void
|
||||
{
|
||||
[$sql, $params] = $this->compiler->compile($this->metadata(), [
|
||||
'activo' => true,
|
||||
'nombre' => 'ana',
|
||||
]);
|
||||
|
||||
self::assertSame('`activo` = ? AND `nombre` = ?', $sql);
|
||||
self::assertSame([true, 'ana'], $params);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_every_cond_operator(): void
|
||||
{
|
||||
$cases = [
|
||||
['neq', Cond::neq(1), '`codigo` <> ?'],
|
||||
['gt', Cond::gt(1), '`codigo` > ?'],
|
||||
['gte', Cond::gte(1), '`codigo` >= ?'],
|
||||
['lt', Cond::lt(1), '`codigo` < ?'],
|
||||
['lte', Cond::lte(1), '`codigo` <= ?'],
|
||||
['like', Cond::like('%a%'), '`codigo` LIKE ?'],
|
||||
['notLike', Cond::notLike('%a%'), '`codigo` NOT LIKE ?'],
|
||||
['between', Cond::between(1, 2), '`codigo` BETWEEN ? AND ?'],
|
||||
['notBetween', Cond::notBetween(1, 2), '`codigo` NOT BETWEEN ? AND ?'],
|
||||
['isNull', Cond::isNull(), '`codigo` IS NULL'],
|
||||
['isNotNull', Cond::isNotNull(), '`codigo` IS NOT NULL'],
|
||||
['in', Cond::in([1, 2]), '`codigo` IN (?, ?)'],
|
||||
['notIn', Cond::notIn([1, 2]), '`codigo` NOT IN (?, ?)'],
|
||||
];
|
||||
|
||||
foreach ($cases as [$label, $cond, $expected]) {
|
||||
[$sql] = $this->compiler->compile($this->metadata(), ['codigo' => $cond]);
|
||||
self::assertSame($expected, $sql, $label);
|
||||
}
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_raw_conditions(): void
|
||||
{
|
||||
[$sql, $params] =
|
||||
$this->compiler->compile($this->metadata(), ['codigo' => Cond::raw('codigo > ?', [
|
||||
10,
|
||||
])]);
|
||||
|
||||
self::assertSame('(codigo > ?)', $sql);
|
||||
self::assertSame([10], $params);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_an_unknown_column_naming_the_valid_ones(): void
|
||||
{
|
||||
$this->expectException(CriteriaException::class);
|
||||
$this->expectExceptionMessage('Unknown column "inexistente"');
|
||||
|
||||
$this->compiler->compile($this->metadata(), ['inexistente' => 1]);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_an_empty_in_cond(): void
|
||||
{
|
||||
$this->expectException(CriteriaException::class);
|
||||
|
||||
$this->compiler->compile($this->metadata(), ['codigo' => Cond::in([])]);
|
||||
}
|
||||
|
||||
private function metadata(): \Camelia\Orm\Metadata\ClassMetadata
|
||||
{
|
||||
return (new MetadataFactory())->forClass(Usuario::class);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit\Query;
|
||||
|
||||
use Camelia\Orm\Exception\CriteriaException;
|
||||
use Camelia\Orm\Metadata\ClassMetadata;
|
||||
use Camelia\Orm\Metadata\MetadataFactory;
|
||||
use Camelia\Orm\Query\MySqlDialect;
|
||||
use Camelia\Orm\Query\QueryBuilder;
|
||||
use Camelia\Orm\Tests\Fixture\Factura;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class QueryBuilderTest extends TestCase
|
||||
{
|
||||
private QueryBuilder $builder;
|
||||
|
||||
private ClassMetadata $usuarios;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$this->builder = new QueryBuilder(new MySqlDialect());
|
||||
$this->usuarios = (new MetadataFactory())->forClass(Usuario::class);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_selects_every_non_relation_column(): void
|
||||
{
|
||||
$compiled = $this->builder->select($this->usuarios, []);
|
||||
|
||||
self::assertSame(
|
||||
'SELECT `codigo`, `nombre`, `correo`, `password_hash`, `activo`, `apodo`, `clave`'
|
||||
. ' FROM `usuarios`',
|
||||
$compiled['sql'],
|
||||
);
|
||||
self::assertSame([], $compiled['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_excludes_relations_from_the_select_list(): void
|
||||
{
|
||||
$metadata = (new MetadataFactory())->forClass(Factura::class);
|
||||
$compiled = $this->builder->select($metadata, []);
|
||||
|
||||
self::assertStringNotContainsString('`usuario`', $compiled['sql']);
|
||||
self::assertStringNotContainsString('`detalles`', $compiled['sql']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_adds_where_order_and_limit(): void
|
||||
{
|
||||
$compiled = $this->builder->select(
|
||||
$this->usuarios,
|
||||
['activo' => true],
|
||||
[['nombre', 'ASC']],
|
||||
10,
|
||||
20,
|
||||
);
|
||||
|
||||
self::assertSame(
|
||||
'SELECT `codigo`, `nombre`, `correo`, `password_hash`, `activo`, `apodo`, `clave`'
|
||||
. ' FROM `usuarios` WHERE `activo` = ?'
|
||||
. ' ORDER BY `usuarios`.`nombre` ASC LIMIT 10 OFFSET 20',
|
||||
$compiled['sql'],
|
||||
);
|
||||
self::assertSame([true], $compiled['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_an_invalid_order_direction(): void
|
||||
{
|
||||
$this->expectException(CriteriaException::class);
|
||||
|
||||
/** @phpstan-ignore-next-line intentionally invalid direction to prove runtime validation */
|
||||
$this->builder->select($this->usuarios, [], [['nombre', 'SIDEWAYS']]);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_restricts_selected_columns_when_asked(): void
|
||||
{
|
||||
$compiled = $this->builder->select(
|
||||
$this->usuarios,
|
||||
[],
|
||||
[],
|
||||
null,
|
||||
null,
|
||||
['codigo', 'nombre'],
|
||||
);
|
||||
|
||||
self::assertStringContainsString('SELECT `codigo`, `nombre` FROM', $compiled['sql']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_count(): void
|
||||
{
|
||||
$compiled = $this->builder->count($this->usuarios, ['activo' => 1]);
|
||||
|
||||
self::assertSame(
|
||||
'SELECT COUNT(*) AS aggregate FROM `usuarios` WHERE `activo` = ?',
|
||||
$compiled['sql'],
|
||||
);
|
||||
self::assertSame([1], $compiled['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_aggregates(): void
|
||||
{
|
||||
$compiled = $this->builder->aggregate($this->usuarios, 'codigo', 'MAX', []);
|
||||
|
||||
self::assertSame('SELECT MAX(`codigo`) AS aggregate FROM `usuarios`', $compiled['sql']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_insert(): void
|
||||
{
|
||||
$compiled = $this->builder->insert($this->usuarios, ['nombre' => 'Ana', 'activo' => true]);
|
||||
|
||||
self::assertSame(
|
||||
'INSERT INTO `usuarios` (`nombre`, `activo`) VALUES (?, ?)',
|
||||
$compiled['sql'],
|
||||
);
|
||||
self::assertSame(['Ana', true], $compiled['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_update(): void
|
||||
{
|
||||
$compiled = $this->builder->update($this->usuarios, ['nombre' => 'Ana'], 7);
|
||||
|
||||
self::assertSame('UPDATE `usuarios` SET `nombre` = ? WHERE `codigo` = ?', $compiled['sql']);
|
||||
self::assertSame(['Ana', 7], $compiled['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_compiles_delete(): void
|
||||
{
|
||||
$compiled = $this->builder->delete($this->usuarios, 7);
|
||||
|
||||
self::assertSame('DELETE FROM `usuarios` WHERE `codigo` = ?', $compiled['sql']);
|
||||
self::assertSame([7], $compiled['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_refuses_an_empty_insert(): void
|
||||
{
|
||||
$this->expectException(CriteriaException::class);
|
||||
|
||||
$this->builder->insert($this->usuarios, []);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_refuses_an_empty_update(): void
|
||||
{
|
||||
$this->expectException(CriteriaException::class);
|
||||
|
||||
$this->builder->update($this->usuarios, [], 1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit;
|
||||
|
||||
use Camelia\Orm\Query\Cond;
|
||||
use Camelia\Orm\Query\GroupCond;
|
||||
use Camelia\Orm\Repository;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use Camelia\Orm\Tests\Support\FakeConnection;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class QueryTest extends TestCase
|
||||
{
|
||||
private FakeConnection $connection;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$this->connection = new FakeConnection();
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_builds_a_select_with_where(): void
|
||||
{
|
||||
$sql = $this->repository(Usuario::class)->query()->where('activo', true)->toSql();
|
||||
|
||||
self::assertStringContainsString('WHERE (`activo` = ?)', $sql['sql']);
|
||||
self::assertSame([true], $sql['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_is_immutable(): void
|
||||
{
|
||||
$base = $this->repository(Usuario::class)->query()->where('activo', true);
|
||||
$derived = $base->where('nombre', 'Ana');
|
||||
|
||||
self::assertCount(1, $base->toSql()['params']);
|
||||
self::assertCount(2, $derived->toSql()['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_places_where_before_order_and_limit(): void
|
||||
{
|
||||
$sql = $this->repository(Usuario::class)
|
||||
->query()
|
||||
->where('activo', true)
|
||||
->orderByDesc('nombre')
|
||||
->limit(5)
|
||||
->toSql()['sql'];
|
||||
|
||||
self::assertStringContainsString('WHERE (`activo` = ?) ORDER BY', $sql);
|
||||
self::assertStringContainsString('LIMIT 5', $sql);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_builds_or_groups(): void
|
||||
{
|
||||
$sql = $this->repository(Usuario::class)
|
||||
->query()
|
||||
->whereGroup(static function (GroupCond $group): void {
|
||||
$group->or('nombre', 'Ana');
|
||||
$group->or('nombre', 'Bea');
|
||||
})
|
||||
->toSql();
|
||||
|
||||
self::assertStringContainsString('WHERE (`nombre` = ? OR `nombre` = ?)', $sql['sql']);
|
||||
self::assertCount(2, $sql['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_combines_groups_with_and(): void
|
||||
{
|
||||
$sql = $this->repository(Usuario::class)
|
||||
->query()
|
||||
->where('activo', true)
|
||||
->whereGroup(static function (GroupCond $group): void {
|
||||
$group->or('nombre', 'Ana');
|
||||
})
|
||||
->toSql()['sql'];
|
||||
|
||||
self::assertStringContainsString('(`activo` = ?) AND', $sql);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_supports_where_in_and_null_helpers(): void
|
||||
{
|
||||
$sql = $this->repository(Usuario::class)
|
||||
->query()
|
||||
->whereIn('codigo', [1, 2])
|
||||
->whereNull('apodo')
|
||||
->toSql();
|
||||
|
||||
self::assertStringContainsString('`codigo` IN (?, ?)', $sql['sql']);
|
||||
self::assertStringContainsString('`apodo` IS NULL', $sql['sql']);
|
||||
self::assertSame([1, 2], $sql['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_plucks_a_single_column(): void
|
||||
{
|
||||
$this->connection->rows = [['nombre' => 'Ana'], ['nombre' => 'Bea']];
|
||||
|
||||
$values = $this->repository(Usuario::class)->query()->pluck('nombre');
|
||||
|
||||
self::assertSame(['Ana', 'Bea'], $values);
|
||||
self::assertStringContainsString(
|
||||
'SELECT `nombre` FROM',
|
||||
$this->connection->selected[0]['sql'],
|
||||
);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_counts(): void
|
||||
{
|
||||
$this->connection->scalars = [4];
|
||||
|
||||
self::assertSame(
|
||||
4,
|
||||
$this->repository(Usuario::class)->query()->where('activo', true)->count(),
|
||||
);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_returns_the_first_row_or_null(): void
|
||||
{
|
||||
$this->connection->rows = [];
|
||||
|
||||
self::assertNull($this->repository(Usuario::class)->query()->first());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_fails_first_or_fail_when_empty(): void
|
||||
{
|
||||
$this->connection->rows = [];
|
||||
|
||||
$this->expectException(\Camelia\Orm\Exception\RecordNotFoundException::class);
|
||||
|
||||
$this->repository(Usuario::class)->query()->firstOrFail();
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_pages(): void
|
||||
{
|
||||
$this->connection->scalars = [0];
|
||||
$this->connection->rows = [];
|
||||
|
||||
$page = $this->repository(Usuario::class)->query()->page(2, 5);
|
||||
|
||||
self::assertSame(2, $page->page);
|
||||
self::assertSame(0, $page->total);
|
||||
self::assertStringContainsString('LIMIT 5 OFFSET 5', $this->connection->selected[1]['sql']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_accepts_a_cond_in_where(): void
|
||||
{
|
||||
$sql = $this->repository(Usuario::class)
|
||||
->query()
|
||||
->where('codigo', Cond::between(1, 9))
|
||||
->toSql();
|
||||
|
||||
self::assertStringContainsString('BETWEEN ? AND ?', $sql['sql']);
|
||||
self::assertSame([1, 9], $sql['params']);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param class-string<\Camelia\Orm\Model> $class
|
||||
* @return Repository<\Camelia\Orm\Model>
|
||||
*/
|
||||
private function repository(string $class): Repository
|
||||
{
|
||||
return new Repository($this->connection, $class);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,234 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit;
|
||||
|
||||
use Camelia\Orm\Exception\RecordNotFoundException;
|
||||
use Camelia\Orm\Pagination\Page;
|
||||
use Camelia\Orm\Query\Cond;
|
||||
use Camelia\Orm\Repository;
|
||||
use Camelia\Orm\Tests\Fixture\Factura;
|
||||
use Camelia\Orm\Tests\Fixture\Usuario;
|
||||
use Camelia\Orm\Tests\Support\FakeConnection;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class RepositoryTest extends TestCase
|
||||
{
|
||||
private FakeConnection $connection;
|
||||
|
||||
protected function setUp(): void
|
||||
{
|
||||
$this->connection = new FakeConnection();
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_hydrates_rows_into_models(): void
|
||||
{
|
||||
$this->connection->rows = [
|
||||
[
|
||||
'codigo' => '5',
|
||||
'nombre' => 'Ana',
|
||||
'correo' => 'a@x',
|
||||
'password_hash' => 'h',
|
||||
'activo' => '1',
|
||||
'apodo' => null,
|
||||
'clave' => 'k',
|
||||
],
|
||||
];
|
||||
|
||||
$result = $this->repository(Usuario::class)->find();
|
||||
|
||||
self::assertCount(1, $result);
|
||||
$usuario = $result[0];
|
||||
self::assertInstanceOf(Usuario::class, $usuario);
|
||||
self::assertSame(5, $usuario->codigo);
|
||||
self::assertSame('Ana', $usuario->nombre);
|
||||
self::assertTrue($usuario->activo);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_returns_null_when_find_first_matches_nothing(): void
|
||||
{
|
||||
$this->connection->rows = [];
|
||||
|
||||
self::assertNull($this->repository(Usuario::class)->findFirst());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_throws_when_find_by_pk_fails(): void
|
||||
{
|
||||
$this->connection->rows = [];
|
||||
|
||||
$this->expectException(RecordNotFoundException::class);
|
||||
|
||||
$this->repository(Usuario::class)->findByPkOrFail(99);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_finds_by_primary_key_through_a_delegated_criteria(): void
|
||||
{
|
||||
$this->connection->rows = [];
|
||||
|
||||
$this->repository(Usuario::class)->findByPk(4);
|
||||
|
||||
self::assertStringContainsString(
|
||||
'WHERE `codigo` = ?',
|
||||
$this->connection->selected[0]['sql'],
|
||||
);
|
||||
self::assertSame([4], $this->connection->selected[0]['params']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_counts_through_a_scalar_query(): void
|
||||
{
|
||||
$this->connection->scalars = [7];
|
||||
|
||||
self::assertSame(7, $this->repository(Usuario::class)->count(['activo' => true]));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_reports_existence(): void
|
||||
{
|
||||
$this->connection->scalars = [1];
|
||||
|
||||
self::assertTrue($this->repository(Usuario::class)->exists(['activo' => true]));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_aggregates(): void
|
||||
{
|
||||
$this->connection->scalars = [10.5, null];
|
||||
|
||||
self::assertSame(10.5, $this->repository(Usuario::class)->sum('codigo'));
|
||||
self::assertNull($this->repository(Usuario::class)->max('codigo'));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_pages_with_total_and_items(): void
|
||||
{
|
||||
$this->connection->scalars = [3];
|
||||
$this->connection->rows = [
|
||||
[
|
||||
'codigo' => '1',
|
||||
'nombre' => 'A',
|
||||
'correo' => '',
|
||||
'password_hash' => '',
|
||||
'activo' => '1',
|
||||
'apodo' => null,
|
||||
'clave' => '',
|
||||
],
|
||||
];
|
||||
|
||||
$page = $this->repository(Usuario::class)->page(
|
||||
['activo' => true],
|
||||
[['nombre', 'DESC']],
|
||||
1,
|
||||
2,
|
||||
);
|
||||
|
||||
self::assertInstanceOf(Page::class, $page);
|
||||
self::assertSame(3, $page->total);
|
||||
self::assertSame(2, $page->totalPages);
|
||||
self::assertCount(1, $page->items);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_creates_a_model_and_inserts_it(): void
|
||||
{
|
||||
$this->connection->lastInsertId = '9';
|
||||
|
||||
$usuario = $this->repository(Usuario::class)->create(['nombre' => 'Ana', 'clave' => 'abc']);
|
||||
|
||||
self::assertInstanceOf(Usuario::class, $usuario);
|
||||
self::assertSame(9, $usuario->codigo);
|
||||
self::assertStringStartsWith('INSERT INTO `usuarios`', $this->connection->lastSql());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_finds_or_creates(): void
|
||||
{
|
||||
$this->connection->rows = [];
|
||||
$this->connection->lastInsertId = '11';
|
||||
|
||||
$usuario = $this->repository(Usuario::class)->findOrCreate(['correo' => 'a@x'], [
|
||||
'nombre' => 'Ana',
|
||||
'clave' => 'abc',
|
||||
]);
|
||||
|
||||
self::assertInstanceOf(Usuario::class, $usuario);
|
||||
self::assertSame('a@x', $usuario->correo);
|
||||
self::assertSame(11, $usuario->codigo);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_loads_a_belongs_to_relation_in_one_query(): void
|
||||
{
|
||||
$this->connection->rows = [$this->usuarioRow(7, 'Ana')];
|
||||
|
||||
$facturaList = $this->repository(Factura::class)->find(with: ['usuario']);
|
||||
|
||||
self::assertCount(1, $facturaList);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_marks_models_partial_when_selecting_columns(): void
|
||||
{
|
||||
$this->connection->rows = [['codigo' => '1', 'nombre' => 'Ana']];
|
||||
|
||||
$result = $this->repository(Usuario::class)->query()->select('codigo', 'nombre')->get();
|
||||
|
||||
self::assertTrue($result[0]->isPartial());
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_rejects_an_unknown_relation(): void
|
||||
{
|
||||
$this->connection->rows = [];
|
||||
|
||||
$this->expectException(\Camelia\Orm\Exception\MetadataException::class);
|
||||
|
||||
$this->repository(Usuario::class)->find(with: ['inexistente']);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_binds_params_in_criteria_order(): void
|
||||
{
|
||||
$this->connection->rows = [];
|
||||
|
||||
$this->repository(Usuario::class)->find(['activo' => true, 'codigo' => Cond::in([1, 2])]);
|
||||
|
||||
self::assertSame([true, 1, 2], $this->connection->selected[0]['params']);
|
||||
self::assertSame(
|
||||
'SELECT `codigo`, `nombre`, `correo`, `password_hash`, `activo`, `apodo`, `clave`'
|
||||
. ' FROM `usuarios` WHERE `activo` = ? AND `codigo` IN (?, ?)',
|
||||
$this->connection->selected[0]['sql'],
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param class-string<\Camelia\Orm\Model> $class
|
||||
* @return Repository<\Camelia\Orm\Model>
|
||||
*/
|
||||
private function repository(string $class): Repository
|
||||
{
|
||||
return new Repository($this->connection, $class);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
private function usuarioRow(int $codigo, string $nombre): array
|
||||
{
|
||||
return [
|
||||
'codigo' => (string) $codigo,
|
||||
'nombre' => $nombre,
|
||||
'correo' => 'a@x',
|
||||
'password_hash' => '',
|
||||
'activo' => '1',
|
||||
'apodo' => null,
|
||||
'clave' => '',
|
||||
];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit\Support;
|
||||
|
||||
use Camelia\Orm\Support\NameConverter;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class NameConverterTest extends TestCase
|
||||
{
|
||||
#[Test]
|
||||
public function it_converts_internal_capitals_to_underscores(): void
|
||||
{
|
||||
self::assertSame('codigo_empresa', NameConverter::camelToSnake('codigoEmpresa'));
|
||||
self::assertSame('id_zona', NameConverter::camelToSnake('idZona'));
|
||||
self::assertSame('normal', NameConverter::camelToSnake('normal'));
|
||||
self::assertSame('', NameConverter::camelToSnake(''));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_never_prefixes_the_first_character(): void
|
||||
{
|
||||
self::assertSame('nombre', NameConverter::camelToSnake('Nombre'));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_round_trips_simple_names(): void
|
||||
{
|
||||
self::assertSame('codigoEmpresa', NameConverter::snakeToCamel('codigo_empresa'));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Camelia\Orm\Tests\Unit\Support;
|
||||
|
||||
use Camelia\Orm\Support\TypeCaster;
|
||||
use DateTimeImmutable;
|
||||
use PHPUnit\Framework\Attributes\DataProvider;
|
||||
use PHPUnit\Framework\Attributes\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
final class TypeCasterTest extends TestCase
|
||||
{
|
||||
#[Test]
|
||||
public function it_casts_numeric_values_to_int(): void
|
||||
{
|
||||
self::assertSame(42, TypeCaster::cast('42', 'int', false));
|
||||
self::assertSame(1, TypeCaster::cast(true, 'int', false));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_casts_boolean_representations(): void
|
||||
{
|
||||
self::assertTrue(TypeCaster::cast('true', 'bool', false));
|
||||
self::assertFalse(TypeCaster::cast('false', 'bool', false));
|
||||
self::assertTrue(TypeCaster::cast(1, 'bool', false));
|
||||
self::assertFalse(TypeCaster::cast('0', 'bool', false));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_decodes_json_strings_into_arrays(): void
|
||||
{
|
||||
self::assertSame(['a' => 1], TypeCaster::cast('{"a":1}', 'array', false));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_casts_dates(): void
|
||||
{
|
||||
$value = TypeCaster::cast('2024-01-15', DateTimeImmutable::class, false);
|
||||
|
||||
self::assertInstanceOf(DateTimeImmutable::class, $value);
|
||||
self::assertSame('2024-01-15', $value->format('Y-m-d'));
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_keeps_null_for_nullable_properties(): void
|
||||
{
|
||||
self::assertNull(TypeCaster::cast(null, 'int', true));
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<string, array{0: mixed, 1: string}>
|
||||
*/
|
||||
public static function refusals(): array
|
||||
{
|
||||
return [
|
||||
'int from text' => ['abc', 'int'],
|
||||
'float from text' => ['abc', 'float'],
|
||||
'bool from text' => ['quizas', 'bool'],
|
||||
'array from text' => ['no json', 'array'],
|
||||
'date from text' => ['no es fecha', DateTimeImmutable::class],
|
||||
];
|
||||
}
|
||||
|
||||
#[Test]
|
||||
#[DataProvider('refusals')]
|
||||
public function it_refuses_values_it_cannot_cast(mixed $value, string $type): void
|
||||
{
|
||||
$this->expectException(\InvalidArgumentException::class);
|
||||
|
||||
TypeCaster::cast($value, $type, false);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_refuses_null_on_a_non_nullable_type(): void
|
||||
{
|
||||
$this->expectException(\InvalidArgumentException::class);
|
||||
|
||||
TypeCaster::cast(null, 'int', false);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_serializes_dates_as_atom_strings(): void
|
||||
{
|
||||
self::assertSame(
|
||||
'2024-01-15T00:00:00+00:00',
|
||||
TypeCaster::toSerializable(
|
||||
new DateTimeImmutable('2024-01-15', new \DateTimeZone('UTC')),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
#[Test]
|
||||
public function it_stores_dates_as_datetime_strings(): void
|
||||
{
|
||||
self::assertSame(
|
||||
'2024-01-15 00:00:00',
|
||||
TypeCaster::toDatabaseValue(
|
||||
new DateTimeImmutable('2024-01-15', new \DateTimeZone('UTC')),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user