Al terminar este bloque vas a poder

Dos decisiones del curso

El código del Bloque II

Prestamo::where('equipo_id', $datos['equipo_id'])
    ->where(function ($q) use ($datos) {
        $q->whereBetween('fecha_inicio', [$datos['fecha_inicio'], $datos['fecha_fin']])
          ->orWhereBetween('fecha_fin', [$datos['fecha_inicio'], $datos['fecha_fin']]);
    })->exists();

Suena razonable y funcionó en la demostración

Pruébalo con un proyector

La pregunta del bloque

Actividad A1 — dibujen todas las posiciones posibles entre dos reservas

El camino del bloque

Modelar antes de guardar

users 1 ─── N prestamos N ─── 1 equipos

Relacional o documental

El mismo préstamo como documento

{
  "_id": "42",
  "usuario": { "id": 7, "nombre": "Ana" },
  "equipo": { "id": 3, "nombre": "Proyector 101" },
  "fechaInicio": "2026-11-10T10:00:00Z"
}

Actividad A3 — decidan tabla o documento para tres datos de su proyecto

La base de datos también se defiende

$table->foreignId('user_id')->constrained();

DB::statement('ALTER TABLE prestamos
  ADD CONSTRAINT chk_prestamos_fechas CHECK (fecha_fin > fecha_inicio)');

STD-DB-P02 y STD-DB-P03

Migraciones que van y vuelven

php artisan migrate
php artisan migrate:rollback
php artisan migrate

STD-DB-M01 y STD-DB-M03

El problema N+1

foreach (Prestamo::all() as $prestamo) {
    echo $prestamo->equipo->nombre;   // una consulta por préstamo
}

Prestamo::with('equipo')->get();      // dos consultas en total

Lo que la validación no resuelve sola

Se llama condición de carrera

Capas módulos y componentes

                 Préstamos             Equipos
Presentación     Controller web + API   Controller API
                 Form Request           Form Request
                 Resource               Resource
Negocio          PrestamoService        (Eloquent basta)
Datos            Repository + Model     Model
                        └──── PostgreSQL ────┘

Qué es una API

Actividad A2 — el contrato de la API de tu proyecto antes de programarla

REST en cinco ideas

• Todo es un recurso con nombre en plural
• Cada recurso tiene su propia URL
• El método dice la acción no la URL
• Cada petición trae todo lo necesario incluido el token
• El código de estado dice el resultado

Métodos HTTP

RFC 9110 HTTP Semantics secciones 9.2.1 y 9.2.2

Códigos que vas a usar

422 o 409

3.2.3 Datos en tránsito

JSON ── petición ──►  deserializar → validar → Service → PostgreSQL
JSON ◄─ respuesta ──  serializar (API Resource) ◄──────────┘

JSON no tiene tipo fecha · RFC 8259

El controlador integra no decide

public function store(GuardarPrestamoRequest $request, PrestamoService $service)
{
    $prestamo = $service->crear([
        ...$request->validated(),
        'user_id' => $request->user()->id,
    ]);

    return PrestamoResource::make($prestamo->load('equipo'))
        ->response()->setStatusCode(201);
}

No todo error es igual

Esperadas e inesperadas

Paso 1 — dale nombre al problema

class ConflictoDeReservaException extends RuntimeException
{
    public function __construct(public readonly ?int $equipoId = null)
    {
        parent::__construct('El equipo ya está reservado en ese horario.');
    }
}

Paso 2 — lanzar donde se detecta

// PrestamoService
public function crear(array $datos): Prestamo
{
    if ($this->repositorio->existeConflicto($datos)) {
        throw new ConflictoDeReservaException((int) $datos['equipo_id']);
    }

    return $this->repositorio->crear($datos);
}

Paso 3 — traducir en un solo lugar

// bootstrap/app.php
$exceptions->render(function (ConflictoDeReservaException $e, Request $request) use ($error) {
    if ($request->is('api/*')) {
        Log::info('Reserva rechazada por conflicto de horario', [
            'equipo_id' => $e->equipoId,
            'user_id' => $request->user()?->id,
        ]);

        return $error('CONFLICTO_RESERVA', $e->getMessage(), [], 409);
    }
});

STD-BE-E02 · un render por excepción conocida · lo demás lo maneja Laravel

Un formato de error para toda la API

{
  "error": {
    "code": "CONFLICTO_RESERVA",
    "message": "El equipo ya está reservado en ese horario.",
    "details": {}
  }
}

Paso 4 — atrapar solo si puedes hacer algo

catch (\Exception $e) { }   // BLOCKER — STD-BE-E03 el error desaparece

Deshacer — todo o nada

DB::transaction(function () use ($datos) {
    $prestamo = Prestamo::create($datos);
    $prestamo->equipo->update(['disponible' => false]);
});

Ejemplo ilustrativo · ReservaFIC no actualiza disponible al prestar

Traducir — error técnico a error de dominio

try {
    $prestamo = $this->repositorio->crear($datos);
} catch (UniqueConstraintViolationException $e) {
    throw new ConflictoDeReservaException((int) $datos['equipo_id']);
}

Ejemplo ilustrativo · solo aplica si existe una restricción única que lo provoque

Lo que ve cada quien

[2026-11-10 10:03:12] local.ERROR: SQLSTATE[08006] connection to server failed
  {"userId":7,"exception":"[object] (Illuminate\\Database\\QueryException ...)"}

Registro ilustrativo

Registrar con contexto y sin secretos

Log::info('Reserva rechazada por conflicto de horario', [
    'equipo_id' => $e->equipoId,
    'user_id' => $request->user()?->id,
]);

Qué es una prueba automatizada

Unitaria o integración

Toda prueba tiene tres partes

Preparar   → los datos y las piezas que la prueba necesita
Actuar     → llamar una sola vez al código que se prueba
Verificar  → comparar el resultado con lo esperado

Ejemplo mínimo — la regla

// Ejemplo de aprendizaje · no forma parte de ReservaFIC
class ReglaHorario
{
    public static function esValido(string $inicio, string $fin): bool
    {
        return strtotime($fin) > strtotime($inicio);
    }
}

Ejemplo mínimo — su prueba

use PHPUnit\Framework\TestCase;

class ReglaHorarioTest extends TestCase
{
    public function test_acepta_un_fin_posterior_al_inicio(): void
    {
        $inicio = '2026-11-10 10:00';                 // Preparar
        $fin = '2026-11-10 12:00';

        $resultado = ReglaHorario::esValido($inicio, $fin);   // Actuar

        $this->assertTrue($resultado);                 // Verificar
    }
}

tests/Unit · extiende PHPUnit\Framework\TestCase · el método empieza con test_

Un positivo no basta

public function test_rechaza_un_fin_anterior_al_inicio(): void
{
    $this->assertFalse(ReglaHorario::esValido('2026-11-10 12:00', '2026-11-10 10:00'));
}

public function test_rechaza_un_fin_igual_al_inicio(): void
{
    $this->assertFalse(ReglaHorario::esValido('2026-11-10 10:00', '2026-11-10 10:00'));
}

Ejecutar y leer el resultado

php artisan test --filter=ReglaHorarioTest

PASS  Tests\Unit\ReglaHorarioTest
  acepta un fin posterior al inicio
  rechaza un fin anterior al inicio
  rechaza un fin igual al inicio

Tests:  3 passed

Salida simplificada · ante una falla PHPUnit muestra lo esperado lo obtenido y la línea

Las aserciones que más usarás

Paso 2 — una unidad con dependencias

Prueba ──► PrestamoService ──► PrestamoRepositoryInterface
                                   ├── EloquentPrestamoRepository   (producción)
                                   └── repositorio falso            (prueba)

Por esto el equipo conserva el Repository · D-008 y ADR-002

El repositorio falso

private function repositorioFalso(bool $hayConflicto): PrestamoRepositoryInterface
{
    return new class($hayConflicto) implements PrestamoRepositoryInterface {
        public array $creados = [];

        public function __construct(private bool $hayConflicto) {}

        public function existeConflicto(array $datos): bool
        {
            return $this->hayConflicto;          // responde lo que la prueba decide
        }

        public function crear(array $datos): Prestamo
        {
            $this->creados[] = $datos;           // recuerda qué le pidieron
            return new Prestamo();
        }
    };
}

Probar el camino feliz

public function test_crea_el_prestamo_cuando_no_hay_conflicto(): void
{
    $repositorio = $this->repositorioFalso(hayConflicto: false);

    (new PrestamoService($repositorio))->crear(['equipo_id' => 1, 'user_id' => 7]);

    $this->assertCount(1, $repositorio->creados);
}

Probar que debe fallar

public function test_lanza_excepcion_y_no_crea_cuando_hay_conflicto(): void
{
    $repositorio = $this->repositorioFalso(hayConflicto: true);

    try {
        (new PrestamoService($repositorio))->crear(['equipo_id' => 1, 'user_id' => 7]);
        $this->fail('Se esperaba ConflictoDeReservaException.');
    } catch (ConflictoDeReservaException $e) {
        $this->assertSame(1, $e->equipoId);
        $this->assertCount(0, $repositorio->creados);
    }
}

Verifica dos cosas — que se lanzó la excepción correcta y que no se guardó nada

Dobles de prueba

¿Qué doble es el repositorio falso?

Stub o mock — qué se verifica

El mismo caso con un mock de PHPUnit

public function test_no_guarda_nada_cuando_hay_conflicto(): void
{
    $repositorio = $this->createMock(PrestamoRepositoryInterface::class);
    $repositorio->method('existeConflicto')->willReturn(true);   // papel de stub
    $repositorio->expects($this->never())->method('crear');      // papel de mock

    $this->expectException(ConflictoDeReservaException::class);

    (new PrestamoService($repositorio))->crear(['equipo_id' => 1, 'user_id' => 7]);
}

createStub() solo responde · createMock() además declara expectativas con expects()

La expectativa es la aserción

$repositorio->expects($this->once())
    ->method('crear')
    ->with($datos)
    ->willReturn(new Prestamo());

(new PrestamoService($repositorio))->crear($datos);

Un fake puede esconder el defecto

Cuándo usar un doble y cuándo no

08-ESTANDAR-PRUEBAS.md §6 · muchos mocks que verifican el orden interno atan la prueba a la implementación

Paso 3 — muchos casos una sola prueba

public static function casos(): array
{
    return [
        'mismo horario'                             => ['10:00', '12:00', true],
        'contenido dentro del existente'            => ['10:30', '11:30', true],
        'termina justo cuando empieza el existente' => ['08:00', '10:00', false],
        'empieza justo cuando termina el existente' => ['12:00', '14:00', false],
    ];
}

#[DataProvider('casos')]
public function test_detecta_traslape_de_horarios(string $inicio, string $fin, bool $esperado): void

Nombres que explican

Errores frecuentes al probar

Buenas prácticas — F.I.R.S.T.

Clean Code · Martin 2008 · retoma las buenas prácticas de Pruebas de Software

Seis prácticas concretas

La lección del defecto

Ocho casos tres fallan

La corrección

Prestamo::where('equipo_id', $datos['equipo_id'])
    ->where('fecha_inicio', '<', $datos['fecha_fin'])
    ->where('fecha_fin', '>', $datos['fecha_inicio'])
    ->exists();

El Service no cambió — el Repository aisló el defecto en un solo lugar

Ver la prueba fallar primero

Actividad A4 — matriz de casos positivos negativos y de borde

Tres fuentes de datos distintas

La base de pruebas se configura aparte

<!-- phpunit.xml -->
<env name="APP_ENV" value="testing"/>
<env name="DB_CONNECTION" value="pgsql"/>
<env name="DB_DATABASE" value="reservafic_testing"/>

Factories — datos coherentes en una línea

// database/factories/EquipoFactory.php
public function definition(): array
{
    return [
        'nombre' => fake()->randomElement(['Laptop', 'Proyector', 'Cámara']).' '.fake()->numerify('###'),
        'descripcion' => fake()->sentence(),
        'disponible' => true,
    ];
}

$equipo = Equipo::factory()->create();            // uno con valores al azar válidos
$equipos = Equipo::factory()->count(5)->create(); // cinco

Fijar solo lo que importa

$equipo = Equipo::factory()->create();

Prestamo::factory()->for($equipo)->create([
    'fecha_inicio' => '2026-11-10 10:00:00',   // lo que la prueba necesita controlar
    'fecha_fin' => '2026-11-10 12:00:00',
]);

STD-TEST §5 · factories y no datos repetidos escritos a mano en cada prueba

Cada prueba empieza en limpio

class PrestamoApiTest extends TestCase
{
    use RefreshDatabase;   // migra una vez y revierte lo de cada prueba

STD-TEST-03 y STD-TEST-04

Seeder o factory

Datos de prueba que no lastiman

• Nunca copies datos de personas reales a la base de pruebas
• Usa fake() para nombres y correos y dominios .test
• La contraseña de la UserFactory es conocida · solo para desarrollo y pruebas
• Los datos de prueba tampoco van al repositorio si salen de una base real

Revisar con severidades

BLOCKER — STD-API-05 el endpoint no está dentro de auth:sanctum y cualquiera puede leer préstamos

Actividad A5 — un merge request lleno de defectos

Principios antes que herramientas

Validar entradas — en la práctica

// Mal: confía en todo lo que manda el cliente
Prestamo::create($request->all());

// Bien: solo lo validado y la identidad desde el token
$service->crear([
    ...$request->validated(),
    'user_id' => $request->user()->id,
]);

STD-SEC-12 y STD-SEC-11

Gestionar errores — fallar de forma segura

Mínimo privilegio — en la práctica

Defensa en profundidad en ReservaFIC

Petición
  │  auth:sanctum         ¿quién eres?                 → 401
  │  Form Request         ¿los datos tienen sentido?   → 422
  │  Policy               ¿puedes hacer esto?          → 403
  │  Service              ¿respeta la regla?           → 409
  ▼  PostgreSQL           FK · NOT NULL · CHECK        → rechaza

Quién eres y qué puedes hacer

¿Ana puede cancelar el préstamo 42?
  ¿es administradora?        → sí puede
  ¿el préstamo es de Ana?    → sí puede
  en otro caso               → 403

Una Policy

public function view(User $usuario, Prestamo $prestamo): bool
{
    return $usuario->esAdministrador()
        || $usuario->id === (int) $prestamo->user_id;
}

Gate::authorize('view', $prestamo);

Qué es un secreto

No son secretos APP_NAME · DB_HOST de tu máquina · el puerto · van en .env.example con su valor

Dónde vive cada secreto

El camino de un secreto en Laravel

.env                  DB_PASSWORD=clave-local-de-ana
  ▼
config/database.php   'password' => env('DB_PASSWORD'),
  ▼
tu código             config('database.connections.pgsql.password')

// Mal: el secreto queda en el repositorio para siempre
$cliente = new ServicioCorreo('sk_live_8f3a...');

// Bien: se lee de la configuración
$cliente = new ServicioCorreo(config('services.correo.key'));

env() solo dentro de config/ · el resto del código usa config()

.env y .env.example

cp .env.example .env
php artisan key:generate

Retomando .gitignore

# Entorno y secretos
.env
.env.*
!.env.example

# Generados
/vendor
/node_modules
.phpunit.result.cache
/storage/*.key

recursos/estandares/config-examples/.gitignore adaptado a un proyecto en la raíz

Cómo lee Git un .gitignore

Comprobar en lugar de suponer

$ git check-ignore -v .env
.gitignore:2:.env	.env

$ git check-ignore -v .env.testing
.gitignore:3:.env.*	.env.testing

$ git status --ignored --short
!! .env
!! vendor/

La trampa — .gitignore no deja de rastrear

$ git ls-files .env
.env                          # Git lo rastrea aunque esté en .gitignore

$ git rm --cached .env        # deja de rastrearlo y conserva tu archivo local
$ git commit -m "chore: dejar de versionar .env"

Si un secreto llegó al historial

git log --all --oneline -- .env

Detectarlo antes de que alguien lo use

Finding:  DB_PASSWORD=REDACTED
File:     config/database.php
Commit:   3f2a1b0

STD-SEC-03 · salida ilustrativa con el secreto ocultado

Configuración insegura

OWASP Top 10:2025

top10.owasp.org/2025 consultado 2026-10-20 · el estándar del proyecto aún cita la edición 2021

Las cuatro del programa

Inyección en una línea

// Vulnerable
DB::select("SELECT * FROM equipos WHERE nombre = '{$request->nombre}'");

// Seguro
Equipo::where('nombre', $request->validated('nombre'))->get();

Actividad A6 — mapa de amenazas de tu proyecto

Integrar poco y seguido

Humble y Farley Continuous Delivery 2010

Lo que hoy haces a mano

composer install
cp .env.example .env && php artisan key:generate
vendor/bin/pint --test
php artisan migrate && php artisan migrate:rollback && php artisan migrate
php artisan test

El vocabulario

Paso 1 — el pipeline más pequeño

# .gitlab-ci.yml
hola:
  image: php:8.3-cli
  script:
    - php -v
    - echo "El pipeline funciona"

En GitLab Build · Pipelines muestra cada ejecución y su registro

Paso 2 — etapas y trabajos

stages:
  - calidad
  - pruebas

estilo:
  stage: calidad
  script:
    - vendor/bin/pint --test

pruebas:
  stage: pruebas
  script:
    - php artisan test

Paso 3 — no repetir la preparación

.php:
  image: php:8.3-cli
  before_script:
    - composer install --prefer-dist --no-progress --no-interaction
    - cp .env.example .env
    - php artisan key:generate

estilo:
  extends: .php
  stage: calidad
  script:
    - vendor/bin/pint --test

Un trabajo que empieza con punto es una plantilla · extends la hereda · el equivalente de compilar en PHP

Paso 4 — una base de datos para las pruebas

variables:
  POSTGRES_DB: reservafic_testing
  POSTGRES_USER: reservafic
  # POSTGRES_PASSWORD vive en Settings · CI/CD · Variables
  DB_CONNECTION: pgsql
  DB_HOST: postgres
  DB_PASSWORD: $POSTGRES_PASSWORD

pruebas:
  extends: .php
  stage: pruebas
  services:
    - postgres:16
  script:
    - php artisan migrate --force
    - php artisan test

Los secretos también en CI

El pipeline del proyecto

calidad   ── estilo     → vendor/bin/pint --test
          └─ secretos   → detección de secretos sobre todo el historial
pruebas   ── pruebas    → migrate · rollback · migrate · php artisan test
                          contra un PostgreSQL efímero

Leer un trabajo en rojo

$ php artisan test
   FAIL  Tests\Feature\Repositories\EloquentPrestamoRepositoryTest
  x detecta traslape de horarios with data set "contenido dentro del existente"
  Failed asserting that false is identical to true.

Tests:  1 failed, 7 passed
ERROR: Job failed: exit code 1

Salida simplificada · lee de abajo hacia arriba hasta encontrar la primera falla

El pipeline decide

El experimento

Lo que la máquina no revisa

Calidad del repositorio

Scrum en este bloque

Actividad A7 — Planning Review y Retrospective de cada sprint

Qué entregas al cierre

Volviendo al problema