Genera tests unitarios automáticos con Claude para tus proyectos

Mira, colega, si hay algo que odio más que un bug en producción es tener que escribir tests unitarios manualmente. Es tedioso, repetitivo y, seamos sinceros, a veces lo dejamos para "después". Pero con Claude, puedes generar tests automáticos en segundos. Te voy a dejar los prompts que uso yo, sin teoría vacía, directo al código.

Prompt 1: Tests básicos para funciones en Node.js

Este prompt te genera tests con Jest para funciones puras. Lo uso siempre que tengo una función de utilería.

// Prompt para Claude:

// Genera tests unitarios con Jest para esta función en Node.js:

// function sum(a, b) { return a + b; }

// Incluye casos: números positivos, negativos, cero, y edge cases como NaN.

// Devuelve el código completo del archivo .test.js

// Salida esperada:

const sum = require('./sum');

test('suma números positivos', () => {

expect(sum(2, 3)).toBe(5);

});

test('suma números negativos', () => {

expect(sum(-1, -1)).toBe(-2);

});

test('suma con cero', () => {

expect(sum(0, 5)).toBe(5);

});

test('maneja NaN', () => {

expect(sum(NaN, 3)).toBeNaN();

});

Prompt 2: Tests para clases en Java con JUnit

Para proyectos Java, tío, este prompt te cubre las espaldas. Lo uso con JUnit 5.

// Prompt para Claude:

// Genera tests unitarios con JUnit 5 para esta clase Java:

// public class Calculator {

// public int divide(int a, int b) {

// if (b == 0) throw new IllegalArgumentException("No se puede dividir por cero");

// return a / b;

// }

// }

// Incluye: caso normal, división exacta, y test de excepción.

// Salida esperada:

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {

private final Calculator calc = new Calculator();

@Test

void testDivideNormal() {

assertEquals(2, calc.divide(10, 5));

}

@Test

void testDivideExacta() {

assertEquals(3, calc.divide(9, 3));

}

@Test

void testDividePorCero() {

assertThrows(IllegalArgumentException.class, () -> {

calc.divide(10, 0);

});

}

}

Prompt 3: Tests con mocks para Node.js (API calls)

Este es mi favorito, colega. Cuando trabajas con APIs externas, necesitas mocks. Claude te los genera al instante.

// Prompt para Claude:

// Genera tests unitarios con Jest para esta función que llama a una API:

// async function getUser(id) {

// const response = await fetch(https://api.example.com/users/${id});

// return response.json();

// }

// Usa jest.mock para simular fetch. Incluye: respuesta exitosa, error 404, y error de red.

// Salida esperada:

const getUser = require('./getUser');

global.fetch = jest.fn();

test('obtiene usuario exitosamente', async () => {

fetch.mockResolvedValueOnce({ json: async () => ({ id: 1, name: 'Nacho' }) });

const user = await getUser(1);

expect(user.name).toBe('Nacho');

});

test('maneja error 404', async () => {

fetch.mockRejectedValueOnce(new Error('Not Found'));

await expect(getUser(999)).rejects.toThrow('Not Found');

});

test('maneja error de red', async () => {

fetch.mockRejectedValueOnce(new Error('Network Error'));

await expect(getUser(0)).rejects.toThrow('Network Error');

});

Prompt 4: Tests de cobertura para funciones asíncronas en Java

Para esos métodos con callbacks o CompletableFuture, este prompt te ahorra dolores de cabeza.

// Prompt para Claude:

// Genera tests unitarios con JUnit 5 para este método asíncrono en Java:

// public CompletableFuture<String> processData(String input) {

// return CompletableFuture.supplyAsync(() -> {

// if (input == null) throw new IllegalArgumentException("Input no puede ser null");

// return "Procesado: " + input.toUpperCase();

// });

// }

// Incluye: caso normal, caso con null, y verifica que el future se complete correctamente.

// Salida esperada:

import org.junit.jupiter.api.Test;

import java.util.concurrent.CompletableFuture;

import static org.junit.jupiter.api.Assertions.*;

class DataProcessorTest {

private final DataProcessor processor = new DataProcessor();

@Test

void testProcessDataNormal() throws Exception {

CompletableFuture<String> future = processor.processData("hola");

assertEquals("Procesado: HOLA", future.get());

}

@Test

void testProcessDataNull() {

assertThrows(IllegalArgumentException.class, () -> {

processor.processData(null).join();

});

}

@Test

void testFutureCompletes() {

CompletableFuture<String> future = processor.processData("test");

assertTrue(future.isDone());

}

}

Prompt 5: Tests de integración para bases de datos (Node.js + MongoDB)

Último y no menos importante, tío. Para tests que tocan base de datos, usa este prompt con mongodb-memory-server.

// Prompt para Claude:

// Genera tests de integración con Jest y mongodb-memory-server para esta función:

// async function saveUser(db, userData) {

// const users = db.collection('users');

// return await users.insertOne(userData);

// }

// Incluye: setup de base de datos en memoria, test de inserción, y limpieza después.

// Salida esperada:

const { MongoMemoryServer } = require('mongodb-memory-server');

const { MongoClient } = require('mongodb');

const saveUser = require('./saveUser');

let mongoServer, client, db;

beforeAll(async () => {

mongoServer = await MongoMemoryServer.create();

client = await MongoClient.connect(mongoServer.getUri());

db = client.db('test');

});

afterAll(async () => {

await client.close();

await mongoServer.stop();

});

test('guarda usuario correctamente', async () => {

const result = await saveUser(db, { name: 'Nacho', age: 35 });

expect(result.insertedId).toBeDefined();

const saved = await db.collection('users').findOne({ _id: result.insertedId });

expect(saved.name).toBe('Nacho');

});

Y tú, colega, ¿qué usas para generar tests unitarios? ¿Claude, Copilot o sigues escribiéndolos a mano como un kamikaze? Cuéntame en los comentarios.