> ## Content Index
> Fetch the complete content index at: https://blog.ifirestone.dev/llms.txt
> Use this file to discover other available public pages before exploring further.

# Probar el aislamiento entre tenants en Laravel: tests de fuga, tests de guarda y lo que aún no detectan: 06 de 08
- URL: https://blog.ifirestone.dev/probar-el-aislamiento-entre-tenants-en-laravel-tests-de-fuga-tests-de-guarda-y-lo-que-aun-no-detectan-06-de-08/
- Published: 2026-11-17T13:00:00.000Z
- Updated: 2026-11-17T13:00:00.000Z
- Description: Cómo demostrar que los datos de cada empresa siguen separados en una app Laravel multi-tenant: fixtures con dos empresas, un test de guarda que detecta modelos sin scope, comprobaciones de jobs y caché, una allowlist para los bypass del scope y sus límites.
- Author: Ivan Firestone
- Tags: multitenant-saas-laravel-es, laravel, testing, security, #spanish

> Cómo demostrar que los datos de cada empresa siguen separados en una app Laravel multi-tenant: fixtures con dos empresas, un test de guarda que detecta modelos sin scope, comprobaciones de jobs y caché, una allowlist para los bypass del scope y sus límites.

Imagina un equipo con 300 tests en verde y una app multi-tenant en producción. Un desarrollador agrega un modelo `Receipt`, escribe la migración con una columna `company_id` y olvida el trait `BelongsToCompany`. Todos los tests siguen pasando. Cada test de la suite crea una empresa, un usuario y un puñado de registros, así que nunca hubo una segunda empresa que viera los recibos de la primera.

El scope del primer artículo de esta serie es tan bueno como los tests que intentan romperlo. Este artículo trata de esos tests: qué escribir, cómo hacer imposible el olvido y dónde los tests dejan de bastar. Se solapa un poco con la sección de pruebas de la hoja de ruta de entrega, y profundiza en un solo tema.

## La suite que solo conocía una empresa

Una suite que crea una empresa demuestra que las funcionalidades funcionan. No dice nada del aislamiento, porque el aislamiento es una afirmación sobre la otra empresa. La primera regla es simple: un test de fuga necesita una segunda empresa con datos reales, y su aserción debe ser sobre esos datos.

Ayuda listar dónde pueden filtrarse los datos de un tenant, porque cada lugar necesita su propia comprobación:

- Lecturas: consultas, listados, agregados, route model binding.
- Escrituras: el `company_id` que recibe un registro nuevo.
- Trabajo en segundo plano: jobs, listeners y tareas programadas que corren sin petición.
- Almacenamiento compartido: claves de caché y rutas de archivos.
- Vías de escape: consultas crudas y cualquier cosa que quite el scope.

## El fixture: dos empresas, la misma forma

Empieza con un helper que dé a cada test dos empresas, y pon los datos ajenos dentro de la otra:

```php
function twoCompanies(): array
{
    return [Company::factory()->create(), Company::factory()->create()];
}

it('devuelve 404 para una factura que pertenece a otra empresa', function () {
    [$mine, $theirs] = twoCompanies();

    $user = User::factory()->create();
    $mine->users()->attach($user);

    $foreign = app(TenantContext::class)->runAs(
        $theirs->id,
        fn () => Invoice::factory()->create(),
    );

    $this->actingAs($user)
        ->get("/{$mine->slug}/invoices/{$foreign->id}")
        ->assertNotFound();

    $this->actingAs($user)
        ->get("/{$mine->slug}/invoices")
        ->assertDontSee($foreign->number);
});

it('devuelve 404 cuando el usuario no es miembro de la empresa de la URL', function () {
    [$mine, $theirs] = twoCompanies();
    $user = User::factory()->create();
    $mine->users()->attach($user);

    $this->actingAs($user)->get("/{$theirs->slug}/invoices")->assertNotFound();
});

```

Los nombres de las relaciones y las factories son supuestos. Lo que importa es la forma: el registro ajeno existe, el usuario está legítimamente dentro de una empresa, y el test pide la otra de dos maneras, por id y por URL. El primer test cubre el route model binding y el listado. El segundo cubre la comprobación de membresía del middleware.

Una trampa: un test que afirma un 404 para un id que no existe en absoluto pasa por la razón equivocada. El registro ajeno tiene que ser real.

## Un test de guarda para el modelo que aún no has escrito

Los tests de fuga escritos a mano solo cubren los modelos en los que alguien pensó. El escenario del principio necesita otro tipo de test, uno que falle cuando un modelo nuevo olvida el trait, haya escrito alguien un test para él o no:

```php
it('aplica scope a todo modelo que tiene una columna company_id', function () {
    $unscoped = collect(File::allFiles(app_path('Models')))
        ->map(fn ($file) => 'App\\Models\\'.$file->getBasename('.php'))
        ->filter(fn ($class) => is_subclass_of($class, Model::class))
        ->reject(fn ($class) => (new ReflectionClass($class))->isAbstract())
        ->reject(fn ($class) => in_array(BelongsToCompany::class, class_uses_recursive($class)))
        ->filter(fn ($class) => Schema::hasColumn((new $class)->getTable(), 'company_id'))
        ->values()
        ->all();

    expect($unscoped)->toBe([]);
});

```

Recorre el directorio de modelos, ignora lo que no sea un modelo concreto y reporta cada modelo cuya tabla tenga una columna `company_id` pero no use el trait. Cuando falla, el diff nombra la clase. Asume un directorio `Models` plano, así que ajusta el mapeo de namespaces si los anidas. Y si un modelo tiene legítimamente la columna sin el scope (una tabla pivote, por ejemplo), ponlo en una lista de excepciones explícita dentro del test, con un comentario.

La comprobación complementaria es que el scope falle cerrado. Es un test corto, y es el que te protege el día en que alguien consulte desde un contexto en el que nadie pensó:

```php
it('se niega a consultar datos de tenant sin una empresa', function () {
    Invoice::query()->count();
})->throws(MissingTenantContext::class);

```

## Poner las vías de escape en una allowlist

Todo sistema necesita unos pocos lugares que miren a través de las empresas: una herramienta de administración que mueve un registro entre ellas, un job nocturno que lee todos los tenants. Está bien. El riesgo es el que nadie notó. Puedes hacer que cada bypass nuevo aparezca como un diff deliberado con un test que escanea el código fuente:

```php
it('mantiene los bypass del scope en una allowlist', function () {
    $needles = ['withoutGlobalScope', 'DB::table(', 'DB::select('];

    $hits = collect(File::allFiles(app_path()))
        ->filter(fn ($file) => collect($needles)->contains(fn ($n) => str_contains($file->getContents(), $n)))
        ->map(fn ($file) => $file->getRelativePathname())
        ->sort()
        ->values()
        ->all();

    expect($hits)->toBe([
        'Console/Commands/ReassignInvoice.php',
        'Tenancy/TenantScope.php',
    ]);
});

```

La lista del test la decides tú. El punto es la fricción: añadir un archivo a ella significa escribirlo en un pull request, donde un revisor pregunta por qué. Un escaneo de texto es tosco y marcará un comentario que mencione alguna de las cadenas. Para una lista tan corta, es un precio aceptable.

## Jobs, caché y archivos

El trabajo en segundo plano es donde el contexto de tenant es más fácil de perder, porque no hay petición que lo lleve. Prueba el middleware que lo restaura, y que después restaura el estado anterior:

```php
it('ejecuta un job dentro de su empresa y no deja contexto atrás', function () {
    $company = Company::factory()->create();
    $tenant = app(TenantContext::class);
    $job = new class($company->id) { public function __construct(public int $companyId) {} };

    (new RunsAsCompany)->handle($job, function () use ($tenant, $company) {
        expect($tenant->id())->toBe($company->id);
    });

    expect($tenant->id())->toBeNull();
});

```

Esto asume que `id()` devuelve `null` cuando no hay empresa definida. Para una comprobación más fuerte, ejecuta el job real con el driver de colas `sync` y verifica su efecto para ambas empresas.

La caché y los archivos se filtran por el nombre. Si las claves se construyen a mano, un prefijo olvidado pone a dos empresas en la misma clave:

```php
function tenantKey(string $key): string
{
    return 'company:'.app(TenantContext::class)->id().':'.$key;
}

it('mantiene separados los valores en caché por empresa', function () {
    [$a, $b] = twoCompanies();
    $tenant = app(TenantContext::class);

    $tenant->runAs($a->id, fn () => Cache::put(tenantKey('dashboard'), 'A'));

    expect($tenant->runAs($b->id, fn () => Cache::get(tenantKey('dashboard'))))->toBeNull();
});

```

Sé honesto sobre lo que esto demuestra: que `tenantKey` funciona. No puede impedir que un desarrollador llame directamente a `Cache::put('dashboard', ...)`. Esa parte es una convención que se impone en la revisión, o envolviendo la caché en una clase pequeña que sea lo único autorizado a llamarla. Los archivos siguen la misma lógica con un prefijo de ruta `companies/{id}/`, y `Storage::fake` hace el test barato.

## Lo que estos tests siguen sin ver

Una suite en verde es evidencia, no prueba. Cuatro huecos que conviene conocer:

- **Consultas crudas.** Los global scopes se aplican a los modelos de Eloquent. Una llamada a `DB::table()` los esquiva, y por eso la allowlist de arriba la busca.
- **Joins.** El scope filtra el modelo del que partiste. Un join a otra tabla de tenant se filtra solo si lo filtras tú.
- **Reglas de validación.** `unique:invoices,number` ejecuta una consulta simple entre todas las empresas. Puede rechazar un número válido porque otra empresa lo usa, y le dice al usuario que ese número existe. Acota la regla con `Rule::unique('invoices', 'number')->where('company_id', $companyId)`, y haz compuesto el índice de la base de datos en `(company_id, number)`.
- **Todo lo que no se te ocurrió.** Para datos donde una sola fuga sería un incidente grave, añade un segundo muro en la base de datos. La row-level security de PostgreSQL es la opción habitual. Añade un ajuste de empresa por transacción y un segundo conjunto de roles de base de datos que administrar, y el último artículo de la serie la cubre.

## Lo que cuesta

Los tests de dos empresas construyen más datos, así que corren más lento que los de una sola. La guarda y la allowlist añaden reglas pequeñas que el equipo debe mantener, y a un desarrollador con prisa le molestarán. Ese es el costo buscado. El fallo caro es el que llega a producción, donde un cliente es el primero en ver la factura de otro cliente.

## Conclusión

La suite del principio falló porque solo conocía a una empresa. Una segunda empresa en el fixture, una guarda que falla cuando un modelo olvida el trait y una allowlist para los lugares que cruzan la línea convierten el aislamiento de una esperanza en algo que el build comprueba en cada commit. Empieza hoy con el test de guarda: toma diez minutos, y te dice enseguida si el escenario del principio ya es cierto en tu app.

El siguiente artículo pasa de prevenir fugas a ver lo que hace cada empresa en producción.