Testar rota de API com node:test e supertest, sem Jest

// src/precos.js
const TABELA = {
  banho: { pequeno: 45, medio: 60, grande: 85 },
  tosa: { pequeno: 70, medio: 90, grande: 120 },
};

export function precoDoServico(servico, porte) {
  const linha = TABELA[servico];
  if (!linha) throw new Error(`Serviço desconhecido: ${servico}`);
  const preco = linha[porte];
  if (preco === undefined) throw new Error(`Porte desconhecido: ${porte}`);
  return preco;
}

// test/precos.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { precoDoServico } from '../src/precos.js';

test('banho de cachorro pequeno custa 45', () => {
  assert.equal(precoDoServico('banho', 'pequeno'), 45);
});

test('tosa de cachorro grande custa 120', () => {
  assert.equal(precoDoServico('tosa', 'grande'), 120);
});

node --test

test('banho de cachorro pequeno custa 45', () => {
  assert.equal(precoDoServico('banho', 'pequeno'), 50);
});

// test/precos.test.js
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { precoDoServico } from '../src/precos.js';

describe('precoDoServico', () => {
  it('cobra 45 pelo banho de cachorro pequeno', () => {
    assert.equal(precoDoServico('banho', 'pequeno'), 45);
  });

  it('cobra 120 pela tosa de cachorro grande', () => {
    assert.equal(precoDoServico('tosa', 'grande'), 120);
  });

  it('recusa serviço fora da tabela', () => {
    assert.throws(() => precoDoServico('hidratacao', 'medio'), {
      message: 'Serviço desconhecido: hidratacao',
    });
  });
});

import { it } from 'node:test';
import assert from 'node:assert/strict';

it('45 e "45" não são a mesma coisa no modo estrito', () => {
  assert.deepEqual({ preco: 45 }, { preco: '45' });
});

// test/ajuda.js — não é teste, mas mora em test/
console.log('este arquivo NAO deveria rodar como teste');
export const tutorPadrao = 'Renata';

// src/app.js — a versão que causa problema
import express from 'express';
import { listar } from './agenda.js';

const app = express();
app.use(express.json());
app.get('/agendamentos', (req, res) => res.json(listar()));

const porta = process.env.PORT ?? 3000;
app.listen(porta, () => console.log(`Pet Feliz ouvindo na porta ${porta}`));

export default app;

PORT=3005 node --test

import http from 'node:http';

// é isto que os dois arquivos de teste fazem, cada um no seu processo:
// app.listen() é http.createServer(app).listen() por baixo
http.createServer().listen(3005, () => console.log('arquivo de teste 1: servidor de pe na 3005'));
http.createServer().listen(3005, () => console.log('arquivo de teste 2: servidor de pe na 3005'));

// src/app.js — monta e exporta, sem escutar
import express from 'express';
import { listar, buscar, agendar } from './agenda.js';
import { precoDoServico } from './precos.js';

const app = express();
app.use(express.json());

app.get('/agendamentos', (req, res) => {
  res.json(listar());
});

app.get('/agendamentos/:id', (req, res) => {
  const agendamento = buscar(Number(req.params.id));
  if (!agendamento) return res.status(404).json({ erro: 'Agendamento não encontrado' });
  res.json(agendamento);
});

export default app;

// src/server.js — o único lugar do projeto com listen
import app from './app.js';

const porta = process.env.PORT ?? 3000;
app.listen(porta, () => console.log(`Pet Feliz ouvindo na porta ${porta}`));

node -e "import('./src/app.js').then(() => console.log('o app carregou e o processo terminou'))"

npm i -D supertest

// test/listar.test.js
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import app from '../src/app.js';

describe('GET /agendamentos', () => {
  it('devolve 200 e uma lista', async () => {
    const resposta = await request(app).get('/agendamentos');

    assert.equal(resposta.status, 200);
    assert.match(resposta.headers['content-type'], /application\/json/);
    assert.deepEqual(resposta.body, []);
  });

  it('devolve 404 para agendamento que não existe', async () => {
    const resposta = await request(app).get('/agendamentos/999');

    assert.equal(resposta.status, 404);
    assert.deepEqual(resposta.body, { erro: 'Agendamento não encontrado' });
  });
});

import request from 'supertest';
import app from './src/app.js';

const primeira = await request(app).get('/agendamentos');
const segunda = await request(app).get('/agendamentos');

console.log('1a chamada:', primeira.request.url);
console.log('2a chamada:', segunda.request.url);

// src/app.js — o trecho do POST
app.post('/agendamentos', (req, res) => {
  const { pet, tutor, servico, porte, horario } = req.body ?? {};
  if (!pet || !tutor) {
    return res.status(400).json({ erro: 'pet e tutor são obrigatórios' });
  }
  const preco = precoDoServico(servico, porte);
  const novo = agendar({ pet, tutor, servico, porte, horario });
  res.status(201).location(`/agendamentos/${novo.id}`).json({ ...novo, preco });
});

// test/agendar.test.js
it('cria o agendamento e devolve 201 com Location', async () => {
  const resposta = await request(app).post('/agendamentos').send({
    pet: 'Amora',
    tutor: 'Renata',
    servico: 'banho',
    porte: 'pequeno',
    horario: '2026-08-24T14:00',
  });

  assert.equal(resposta.status, 201);
  assert.equal(resposta.headers.location, '/agendamentos/1');
  assert.equal(resposta.body.pet, 'Amora');
  assert.equal(resposta.body.preco, 45);
});

it('recusa cadastro sem tutor com 400', async () => {
  const resposta = await request(app)
    .post('/agendamentos')
    .send({ pet: 'Amora', servico: 'banho', porte: 'pequeno' });

  assert.equal(resposta.status, 400);
  assert.deepEqual(resposta.body, { erro: 'pet e tutor são obrigatórios' });
});

it('o que foi criado aparece no GET seguinte', async () => {
  await request(app)
    .post('/agendamentos')
    .send({ pet: 'Thor', tutor: 'Caio', servico: 'tosa', porte: 'grande' });

  const lista = await request(app).get('/agendamentos');

  assert.equal(lista.body.length, 1);
  assert.equal(lista.body[0].pet, 'Thor');
});