Concepto clave

En dbt, los tests son validaciones que aseguran la calidad de tus datos transformados. Piensa en ellos como inspectores de control de calidad en una fábrica: revisan cada producto (tus tablas y columnas) antes de enviarlos a producción. Existen dos tipos principales: tests genéricos y tests singulares.

Los tests genéricos son plantillas reutilizables que dbt proporciona para verificar propiedades comunes, como que una columna no tenga valores nulos o que sea única. Son como herramientas estandarizadas: rápidas de aplicar y consistentes. Por otro lado, los tests singulares son validaciones personalizadas que tú escribes para reglas de negocio específicas, como asegurar que el total de ventas sea positivo o que una fecha esté en un rango válido. Son como inspecciones a medida para casos especiales.

La analogía del mundo real: imagina que eres un chef preparando un menú. Los tests genéricos verifican ingredientes básicos (ej., "la sal no está vencida"), mientras que los singulares chequean recetas complejas (ej., "la salsa tiene el equilibrio correcto de sabores"). En dbt Cloud, combinar ambos tipos te permite automatizar la calidad de datos, reduciendo errores en tus análisis.

Cómo funciona en la práctica

Veamos un ejemplo paso a paso para un modelo de ventas. Supón que tienes una tabla stg_orders con columnas como order_id, customer_id, amount, y order_date. Primero, aplicas tests genéricos en el archivo schema.yml para validar propiedades básicas:

Verifica que order_id sea único y no nulo.
Asegura que amount sea positivo (usando un test genérico de positividad).
Confirma que customer_id no tenga valores nulos.

Luego, creas un test singular para una regla de negocio: "el monto total por pedido no debe exceder $10,000". Esto se escribe en un archivo SQL separado y se referencia en schema.yml. Al ejecutar dbt test en dbt Cloud, ambos tipos de tests se corren automáticamente, mostrando fallas si los datos no cumplen las reglas. Esto te alerta temprano sobre problemas, antes de que afecten los reportes.

Código en acción

Aquí tienes un ejemplo funcional. Primero, el archivo models/schema.yml con tests genéricos:

version: 2

models:
  - name: stg_orders
    columns:
      - name: order_id
        tests:
          - unique
          - not_null
      - name: amount
        tests:
          - accepted_values:
              values: ['positive']
      - name: customer_id
        tests:
          - not_null
      - name: order_date
        tests:
          - relationships:
              to: ref('dim_date')
              field: date_key

Ahora, un test singular en tests/amount_limit.sql:

-- Test singular: verifica que el monto por pedido no exceda $10,000
SELECT 
    order_id,
    amount
FROM 
    {{ ref('stg_orders') }}
WHERE 
    amount > 10000

Para integrarlo, añade en schema.yml:

models:
  - name: stg_orders
    tests:
      - amount_limit

Al ejecutar dbt test, si algún pedido tiene amount > 10000, el test fallará, mostrando esos registros. Esto te permite corregir datos erróneos antes de usarlos en dashboards.

Errores comunes

Usar tests singulares para validaciones genéricas: Por ejemplo, escribir un test SQL personalizado para verificar valores no nulos, en lugar de usar not_null. Esto aumenta mantenimiento. Solución: Aprovecha los tests genéricos de dbt siempre que sea posible.
No probar en entorno de staging: Ejecutar tests solo en producción puede causar interrupciones. Solución: Configura dbt Cloud para correr tests en un entorno de staging primero, usando dbt test --target staging.
Ignorar el rendimiento de tests: Tests complejos en tablas grandes pueden ralentizar las ejecuciones. Solución: Optimiza consultas SQL en tests singulares y usa filtros donde aplique.
Falta de documentación en tests: Tests sin explicación clara dificultan el debugging. Solución: Añade comentarios en código YAML o SQL describiendo el propósito de cada test.
No actualizar tests tras cambios en modelos: Si refactorizas una tabla, los tests pueden quedar obsoletos. Solución: Revisa y ajusta tests como parte de tu flujo de desarrollo en dbt Cloud.

Checklist de dominio

Puedo diferenciar entre tests genéricos (ej., unique, not_null) y singulares (SQL personalizado).
Sé configurar tests genéricos en schema.yml para columnas de un modelo.
Puedo crear un test singular en un archivo .sql y referenciarlo en YAML.
Entiendo cómo ejecutar tests en dbt Cloud usando el comando dbt test o la interfaz web.
Puedo interpretar resultados de tests fallidos para identificar problemas en los datos.
Sé optimizar tests para no impactar el rendimiento en ejecuciones grandes.
Puedo documentar tests con comentarios para facilitar mantenimiento.

Implementa tests en un modelo de productos

En este ejercicio, aplicarás tests genéricos y singulares a un modelo de productos para asegurar calidad de datos. Sigue estos pasos:

Prepara el entorno: En tu proyecto dbt Cloud, crea o usa un modelo existente llamado stg_products con columnas: product_id (entero), product_name (texto), price (decimal), category (texto), y created_at (timestamp).
Añade tests genéricos: En el archivo models/schema.yml, configura tests para:
- product_id: debe ser único y no nulo.
- price: debe ser positivo.
- category: debe tener solo valores de una lista predefinida (ej., 'Electrónica', 'Ropa', 'Hogar').
Crea un test singular: Escribe un test en tests/price_threshold.sql que verifique que ningún producto tenga precio mayor a $5000. Referencia este test en schema.yml.
Ejecuta y valida: Corre dbt test en dbt Cloud. Si hay fallos, revisa los datos y ajusta los tests o el modelo según sea necesario.
Documenta: Añade comentarios en el código YAML y SQL explicando el propósito de cada test.

Pistas

Usa el test genérico 'accepted_values' para validar la categoría con una lista de valores.
En el test singular, la consulta SQL debe seleccionar registros que violen la regla (precio > 5000).
Recuerda que los tests singulares se referencian en 'tests:' a nivel de modelo en schema.yml.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Tipos de Tests en dbt: Genericos y Singulares