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:
dgarcia committed 2026-11-15 10:14:22 -03:00
commit 66e93e3070
97 files changed
+12188

No files matched your search

+29
View File
@@ -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 = [];
}
+31
View File
@@ -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';
}
}
+21
View File
@@ -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 = '';
}
+34
View File
@@ -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 = [];
}
+32
View File
@@ -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 = '';
}
+19
View File
@@ -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;
}
+14
View File
@@ -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 = '';
}
+14
View File
@@ -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;
}
+18
View File
@@ -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;
}
+35
View File
@@ -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 = '';
}
+119
View File
@@ -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'];
}
}
+205
View File
@@ -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' => '',
];
}
}
+139
View File
@@ -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);
}
}
+166
View File
@@ -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());
}
}
+70
View File
@@ -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());
}
}
+59
View File
@@ -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']);
}
}
+177
View File
@@ -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);
}
}
+148
View File
@@ -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);
}
}
+161
View File
@@ -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);
}
}
+176
View File
@@ -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);
}
}
+234
View File
@@ -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' => '',
];
}
}
+33
View File
@@ -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'));
}
}
+104
View File
@@ -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')),
),
);
}
}