React 19 limpio: sacamos la lógica a hooks useSetup y aislamos los testsArtículo · digest del 20 de octubre
Bodegón de escritorio de ingeniería con un cuaderno de arquitectura useSetup y una pantalla con tests rápidos de componentes aislados en React 19.
Artículo2 secciones≈ 5 min

React 19 limpio: sacamos la lógica a hooks useSetup y aislamos los tests

¿Cuántas veces has abierto un componente en un proyecto real de React y te has encontrado una mezcla explosiva de una decena de useState, condiciones de carga, comprobaciones de permisos y kilómetros de JSX? En React 19, los componentes siguen convirtiéndose a menudo en monstruos torpes, dolorosos de mantener y casi imposibles de testear sin sufrir.

Cuando escribes tests para un componente así usando el render estándar de React Testing Library, el test se hunde hasta el fondo de todos los nodos hijos. Cualquier retoque de estilos o reordenamiento interno en una tarjeta pequeña rompe los tests del panel padre decenas de pantallas más arriba.

El ingeniero Evgeny Plotnikov (@bad4iz) propuso una solución elegante a este problema: el patrón arquitectónico useSetup[Component], inspirado en la sección setup de Vue 3, combinado con la ligera librería de testing superficial Shallowly para Vitest.

Separación de responsabilidades: un hook para la lógica, el componente para el JSX

La idea es sencilla: el componente debe seguir siendo una función visual pura. Toda la lógica de preparación de datos, estados de carga y transformación de modelos se extrae a un hook propio con el prefijo useSetup:

// src/useSetupProfilePanel.ts
import { useProfile } from './useProfile';

export function useSetupProfilePanel() {
  const state = useProfile();

  if (state.status === 'loading') {
    return {
      isLoading: true as const,
      userCardProps: null,
    };
  }

  return {
    isLoading: false as const,
    userCardProps: {
      name: state.profile.name,
    },
  };
}

Ahora mira lo transparente y legible que queda el propio componente:

// src/ProfilePanel.tsx
import { UserCard } from './UserCard';
import { useSetupProfilePanel } from './useSetupProfilePanel';

export function ProfilePanel() {
  const { isLoading, userCardProps } = useSetupProfilePanel();

  if (isLoading) {
    return <p role="status">Loading profile...</p>;
  }

  return (
    <section aria-label="Profile">
      <h1>Your profile</h1>
      <UserCard {...userCardProps} />
    </section>
  );
}

El componente ya no sabe nada sobre las fuentes de datos. Simplemente toma las props listas y las distribuye por el árbol de elementos.

Estrategia de testing en tres niveles

Con esta estructura, las pruebas se dividen en tres niveles claros sin duplicar comprobaciones:

  1. Test de la lógica del hook: probamos useSetupProfilePanel mediante renderHook simulando las respuestas de red.
  2. Test superficial (shallow) del marcado: comprobamos que el padre pasa correctamente las props al nodo hijo UserCard y renderiza los atributos de accesibilidad (role, aria-label).
  3. Test DOM de integración: lo ejecutamos solo donde hace falta verificar un flujo completo de usuario.

Para el segundo nivel entra en escena la librería Shallowly (el reemplazo moderno del antiguo Enzyme, adaptado a React 18/19 y Vitest):

// src/ProfilePanel.shallow.test.tsx
import { shallow } from 'shallowly';
import { describe, expect, it, vi } from 'vitest';
import { ProfilePanel } from './ProfilePanel';
import { UserCard } from './UserCard';
import { useSetupProfilePanel } from './useSetupProfilePanel';

vi.mock('./useSetupProfilePanel');

describe('ProfilePanel shallow tests', () => {
  it('передает подготовленные свойства в дочернюю карточку', () => {
    const userCardProps = { name: 'Алексей' };
    useSetupProfilePanel.mockReturnValue({ isLoading: false, userCardProps });

    const wrapper = shallow(<ProfilePanel />);
    expect(wrapper.find(UserCard).props()).toEqual(userCardProps);
  });

  it('отображает статус загрузки без рендеринга карточки', () => {
    useSetupProfilePanel.mockReturnValue({ isLoading: true, userCardProps: null });

    const wrapper = shallow(<ProfilePanel />);
    expect(wrapper.find('p').props()).toEqual({
      role: 'status',
      children: 'Loading profile...',
    });
    expect(wrapper.find(UserCard).exists()).toBe(false);
  });
});

En el test con Shallowly, el componente UserCard ni siquiera se inicializa: sus hooks no se ejecutan, no se envían peticiones de red y la prueba termina en cuestión de milisegundos.

Cómo ejecutar el proyecto demo en local

Para probar este enfoque en Node.js 22 o 24, basta con clonar el repositorio oficial con la etiqueta del artículo y lanzar los tests:

git clone --branch profile-panel-article-v3 --single-branch https://github.com/bad4iz/unit-test-article.git
cd unit-test-article/examples/profile-panel
npm ci && npm test && npm run typecheck

Los 6 tests (incluidos los shallow, de hooks y de DOM) pasan en fracciones de segundo sin un solo error de tipos.

Este enfoque exige disciplina al crear archivos, pero se amortiza al instante: los tests dejan de ser frágiles y la lógica y el marcado viven independientes el uno del otro.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2