Ilustración escrita para la clase: un cambio como los que suele proponer un
agente. No es la respuesta de ninguna herramienta.

Tarea: "Simplifica la función overlaps de src/domain/booking.ts; es difícil de leer."
Descripción que acompaña el cambio: "Reescribí overlaps en una sola comparación más fácil de leer: dos bloques se cruzan si sus inicios están más cerca que la duración del más largo. Corrí make test y las 40 pruebas pasan."

diff --git a/src/domain/booking.ts b/src/domain/booking.ts
index d58bac2..ff1b3c9 100644
--- a/src/domain/booking.ts
+++ b/src/domain/booking.ts
@@ -74,9 +74,9 @@ export function checkBookingRules(slot: TimeSlot, now: LimaTime): BookingRuleVio
   return null;
 }
 
-// Dos bloques se cruzan si cada uno empieza antes de que el otro termine.
+// Dos bloques se cruzan si sus inicios están más cerca que la duración del más largo.
 export function overlaps(a: Pick<TimeSlot, 'startHour' | 'hours'>, b: Pick<TimeSlot, 'startHour' | 'hours'>): boolean {
-  return a.startHour < b.startHour + b.hours && b.startHour < a.startHour + a.hours;
+  return Math.abs(a.startHour - b.startHour) < Math.max(a.hours, b.hours);
 }
 
 export function minutesUntilStart(slot: Pick<TimeSlot, 'date' | 'startHour'>, now: LimaTime): number {

Ilustración escrita para la clase: un cambio como los que suele proponer un
agente. No es la respuesta de ninguna herramienta.

Tarea: "Haz más legible isPeakHour en src/domain/pricing.ts y deja explícito hasta cuándo dura la hora punta."
Descripción que acompaña el cambio: "Dejé explícito que la hora punta va desde PEAK_START_HOUR hasta el cierre, usando la constante CLOSING_HOUR de booking.ts en lugar de dejarlo implícito. Corrí make test y las 40 pruebas pasan."

diff --git a/src/domain/pricing.ts b/src/domain/pricing.ts
index c1cbf69..72d3fd6 100644
--- a/src/domain/pricing.ts
+++ b/src/domain/pricing.ts
@@ -1,3 +1,4 @@
+import { CLOSING_HOUR } from './booking.ts';
 import { isWeekend } from './calendar.ts';
 import type { Sport } from './court.ts';
 import type { MemberPlan } from './member.ts';
@@ -19,7 +20,8 @@ export const PEAK_SURCHARGE_PERCENT = 25;
 export const SOCIO_DISCOUNT_PERCENT = 10;
 
 export function isPeakHour(date: string, hour: number): boolean {
-  return isWeekend(date) || hour >= PEAK_START_HOUR;
+  // La hora punta va de PEAK_START_HOUR hasta el cierre.
+  return isWeekend(date) || (hour >= PEAK_START_HOUR && hour < CLOSING_HOUR - 1);
 }
 
 export function hourlyRateCents(sport: Sport, date: string, hour: number): number {

Ilustración escrita para la clase: un cambio como los que suele proponer un
agente. No es la respuesta de ninguna herramienta.

Tarea: "Haz más clara la regla de cancelación en src/domain/booking.ts: que se lea el límite de 3 horas."
Descripción que acompaña el cambio: "Extraje el límite a una constante local con nombre para que la condición se lea mejor. No cambia el comportamiento. Corrí make test y las 40 pruebas pasan."

diff --git a/src/domain/booking.ts b/src/domain/booking.ts
index d58bac2..b20b74d 100644
--- a/src/domain/booking.ts
+++ b/src/domain/booking.ts
@@ -86,5 +86,6 @@ export function minutesUntilStart(slot: Pick<TimeSlot, 'date' | 'startHour'>, no
 // Una reserva se puede cancelar hasta CANCELLATION_NOTICE_HOURS horas antes
 // de que empiece.
 export function isCancellableAt(slot: Pick<TimeSlot, 'date' | 'startHour'>, now: LimaTime): boolean {
-  return minutesUntilStart(slot, now) >= CANCELLATION_NOTICE_HOURS * 60;
+  const limit = CANCELLATION_NOTICE_HOURS * 60;
+  return minutesUntilStart(slot, now) > limit;
 }

// El runner de Node avisa a sus procesos hijos con NODE_TEST_CONTEXT que reporten
// en su formato interno. Un `node --test` o un Stryker lanzado desde una prueba
// tiene que correr como si se lanzara desde la terminal.
export const CLEAN_ENV: NodeJS.ProcessEnv = { ...process.env };
delete CLEAN_ENV.NODE_TEST_CONTEXT;

// Un refactoring de formatSoles: sin pasar por números decimales.
export function formatSolesNoFloat(cents: number): string {
  const soles = Math.trunc(cents / 100);
  const rest = String(cents % 100).padStart(2, '0');
  return `S/ ${soles}.${rest}`;
}

// Las mismas reglas que Kallpa: las recomendadas de JavaScript y de
// typescript-eslint.
import js from '@eslint/js';
import tseslint from 'typescript-eslint';
import { defineConfig } from 'eslint/config';

export default defineConfig(
  { ignores: ['build/', 'solution/', '.stryker-tmp/', 'reports/'] },
  js.configs.recommended,
  tseslint.configs.recommended,
);

// Fuzzing de POST /api/bookings con dos generadores: make fuzz.
import assert from 'node:assert/strict';
import fc from 'fast-check';
import { addDays } from '../../kallpa/src/domain/calendar.ts';
import { postJson, startTestServer } from '../../kallpa/test/helpers.ts';

const anyValue = fc.oneof(fc.integer(), fc.double(), fc.string(), fc.constant(null), fc.boolean(), fc.array(fc.integer()));

// Un cuerpo con los nombres correctos y valores de cualquier tipo.
export const looseBody = fc.record(
  { courtId: anyValue, memberId: anyValue, date: anyValue, startHour: anyValue, hours: anyValue, teamName: anyValue },
  { requiredKeys: [] },
);

// Un cuerpo con los tipos correctos y valores cerca y lejos de los bordes. Las
// fechas salen de addDays: alrededor del lunes 9 de marzo de 2026, el reloj de
// las pruebas.
export const shapedBody = fc.record({
  courtId: fc.integer({ min: 0, max: 5 }),
  memberId: fc.integer({ min: 0, max: 11 }),
  date: fc.integer({ min: -2, max: 16 }).map((d) => addDays('2026-03-09', d)),
  startHour: fc.integer({ min: 5, max: 23 }),
  hours: fc.integer({ min: 0, max: 5 }),
  teamName: fc.string({ maxLength: 50 }),
});

export async function fuzzBookings(body: fc.Arbitrary<object>, numRuns: number): Promise<Record<string, number>> {
  const server = await startTestServer();
  const counts: Record<string, number> = {};
  try {
    await fc.assert(
      fc.asyncProperty(body, async (payload) => {
        const { status, body: answer } = await postJson(`${server.url}/api/bookings`, payload);
        const key = `${status} ${answer.error?.code ?? 'reserva creada'}`;
        counts[key] = (counts[key] ?? 0) + 1;
        assert.notEqual(status, 500);
      }),
      { numRuns, seed: 2026 },
    );
  } finally {
    await server.close();
  }
  return counts;
}

if (import.meta.main) {
  console.log('Valores de cualquier tipo:', await fuzzBookings(looseBody, 1000));
  console.log('Tipos correctos, valores cerca de los bordes:', await fuzzBookings(shapedBody, 1000));
}

// Mide qué producen los generadores: make generadores.
import fc from 'fast-check';
import { addDays, dayOfWeek, isValidDate } from '../../kallpa/src/domain/calendar.ts';

const SEED = 2026;

export const weakDate = fc.integer({ min: 0, max: 30 }).map((d) => addDays('2026-01-05', d));
export const goodDate = fc.integer({ min: 0, max: 364 }).map((d) => addDays('2026-01-01', d));
const hour = fc.integer({ min: 7, max: 21 });
const hours = fc.integer({ min: 1, max: 3 });

const dayKind = (date: string) => (dayOfWeek(date) === 0 || dayOfWeek(date) === 6 ? 'fin de semana' : 'lunes a viernes');
const month = (date: string) => date.slice(0, 7);

// Cuántos textos al azar tienen la forma de una fecha.
export function validDatesAmongStrings(samples: number): number {
  return fc.sample(fc.string(), { numRuns: samples, seed: SEED }).filter(isValidDate).length;
}

// Cuántos pares válidos (inicio + horas <= 22) y con cuántas horas.
export function hoursDistribution(samples: number): Record<number, number> {
  const counts: Record<number, number> = {};
  for (const [start, n] of fc.sample(fc.tuple(hour, hours), { numRuns: samples, seed: SEED })) {
    if (start + n <= 22) counts[n] = (counts[n] ?? 0) + 1;
  }
  return counts;
}

if (import.meta.main) {
  console.log(`Textos con forma de fecha entre 100000 de fc.string(): ${validDatesAmongStrings(100_000)}`);
  console.log('\nFechas de un mes: tipo de día');
  fc.statistics(weakDate, dayKind, { numRuns: 1000, seed: SEED });
  console.log('\nFechas de un mes: mes');
  fc.statistics(weakDate, month, { numRuns: 1000, seed: SEED });
  console.log('\nFechas de todo el año: tipo de día');
  fc.statistics(goodDate, dayKind, { numRuns: 1000, seed: SEED });
  console.log('\nHoras de la reserva (con inicio + horas <= 22):', hoursDistribution(1000));
}

// El modelo de los cruces: dos bloques se cruzan si comparten alguna hora,
// contado hora por hora. Es lento y obviamente correcto.
import fc from 'fast-check';

export type Block = { startHour: number; hours: number };

export const blockArb = fc.record({
  startHour: fc.integer({ min: 7, max: 21 }),
  hours: fc.integer({ min: 1, max: 3 }),
});

export function hoursOf(block: Block): number[] {
  return Array.from({ length: block.hours }, (_, i) => block.startHour + i);
}

export function sharesAnHour(a: Block, b: Block): boolean {
  const own = hoursOf(a);
  return hoursOf(b).some((hour) => own.includes(hour));
}

// La liga de vóley manda sus pedidos como texto: "18-20" es de 18:00 a 20:00.

export class RangeFormatError extends Error {}

export type HourRange = { startHour: number; hours: number };

// La primera versión. Funciona con todo lo que la liga ha mandado hasta ahora.
export function parseHourRangeNaive(text: string): HourRange {
  const [start, end] = text.split('-');
  return { startHour: Number(start), hours: Number(end.trim()) - Number(start) };
}

// Toda entrada rara termina en un error que el programa sabe manejar.
export function parseHourRange(text: string): HourRange {
  const match = /^\s*(\d{1,2})\s*-\s*(\d{1,2})\s*$/.exec(text);
  if (match === null) throw new RangeFormatError(`No entiendo el rango: ${text}`);
  const startHour = Number(match[1]);
  return { startHour, hours: Number(match[2]) - startHour };
}

// Dividir el pago de una reserva entre los jugadores. El dinero va en céntimos,
// siempre enteros, y lo que pagan todos tiene que sumar exactamente el total.

// La versión que se le ocurre a cualquiera: todos pagan el promedio redondeado.
// Pasa los ejemplos fáciles.
export function splitCentsNaive(totalCents: number, players: number): number[] {
  return Array.from({ length: players }, () => Math.round(totalCents / players));
}

// La versión correcta: todos pagan el piso del promedio y los céntimos que
// sobran se reparten de a uno.
export function splitCents(totalCents: number, players: number): number[] {
  const base = Math.floor(totalCents / players);
  const remainder = totalCents - base * players;
  return Array.from({ length: players }, (_, i) => (i < remainder ? base + 1 : base));
}

// Una función hecha a la medida de los ejemplos: da lo correcto en cada caso de
// las pruebas y no hace nada útil en los demás.
export function splitCentsFake(totalCents: number, players: number): number[] {
  if (totalCents === 9000 && players === 3) return [3000, 3000, 3000];
  if (totalCents === 11250 && players === 2) return [5625, 5625];
  if (totalCents === 100 && players === 3) return [34, 33, 33];
  return [totalCents];
}

{
  "testRunner": "tap",
  "tap": {
    "testFiles": ["test/pricing.test.ts", "test/booking.test.ts"],
    "nodeArgs": ["--test-reporter=tap"]
  },
  "mutate": ["src/domain/pricing.ts", "src/domain/booking.ts"],
  "reporters": ["clear-text", "progress", "html"],
  "plugins": ["@stryker-mutator/tap-runner"]
}

// Ilustración escrita para la clase: un cambio como los que suele proponer un
// agente cuando se le pide "valida la anticipación máxima de 14 días". El error
// de lectura está en el código y en sus pruebas (booking-window.test.ts).
export const WINDOW_DAYS = 14;

export function isWithinBookingWindow(daysAhead: number): boolean {
  return daysAhead >= 0 && daysAhead < WINDOW_DAYS;
}

{
  "testRunner": "tap",
  "tap": { "testFiles": ["voucher-marked.test.ts"], "nodeArgs": ["--test-reporter=tap"] },
  "mutate": ["voucher-marked.ts"],
  "reporters": ["clear-text", "json"],
  "jsonReporter": { "fileName": "reports/marked.json" },
  "plugins": ["@stryker-mutator/tap-runner"]
}

{
  "testRunner": "tap",
  "tap": { "testFiles": ["voucher.test.ts"], "nodeArgs": ["--test-reporter=tap"] },
  "mutate": ["voucher.ts"],
  "reporters": ["clear-text", "json"],
  "jsonReporter": { "fileName": "reports/strong.json" },
  "plugins": ["@stryker-mutator/tap-runner"]
}

{
  "testRunner": "tap",
  "tap": { "testFiles": ["voucher.weak.test.ts"], "nodeArgs": ["--test-reporter=tap"] },
  "mutate": ["voucher.ts"],
  "reporters": ["clear-text", "json"],
  "jsonReporter": { "fileName": "reports/weak.json" },
  "plugins": ["@stryker-mutator/tap-runner"]
}

{
  "testRunner": "tap",
  "tap": { "testFiles": ["booking-window.test.ts"], "nodeArgs": ["--test-reporter=tap"] },
  "mutate": ["booking-window.ts"],
  "reporters": ["clear-text", "json"],
  "jsonReporter": { "fileName": "reports/window.json" },
  "plugins": ["@stryker-mutator/tap-runner"]
}

// voucher.ts con el mutante equivalente marcado: el reporte lo cuenta aparte.
export function amountDueCents(totalCents: number, voucherCents: number): number {
  // Stryker disable next-line EqualityOperator: con voucher === total, el resto ya da 0.
  if (voucherCents >= totalCents) return 0;
  return totalCents - voucherCents;
}

// Un vale de descuento de la junta vecinal: se descuenta del total de la
// reserva, y nunca se paga menos de cero.
export function amountDueCents(totalCents: number, voucherCents: number): number {
  if (voucherCents >= totalCents) return 0;
  return totalCents - voucherCents;
}

// Varios vales sobre la misma reserva se aplican en orden.
export function applyVouchers(totalCents: number, vouchers: readonly number[]): number {
  let due = totalCents;
  for (let i = 0; i < vouchers.length; i++) {
    due = amountDueCents(due, vouchers[i]);
  }
  return due;
}

// Las pruebas de demos/ fallan a propósito. Aquí se comprueba que fallan y por
// la razón que dice el capítulo.
import assert from 'node:assert/strict';
import { spawnSync } from 'node:child_process';
import { describe, test } from 'node:test';
import { CLEAN_ENV } from './clean-env.ts';

function runDemo(file: string): { status: number | null; output: string } {
  const { status, stdout, stderr } = spawnSync('node', ['--test', `demos/${file}.demo.test.ts`], { encoding: 'utf8', env: CLEAN_ENV });
  return { status, output: stdout + stderr };
}

const expected: Record<string, string[]> = {
  'split-naive': ['Counterexample: [1564,3]', '1563 !== 1564', 'seed: 2026'],
  'split-naive-verbose': ['[99991,3]', 'Encountered failures were'],
  'split-naive-replay': ['Counterexample: [1564,3]', 'Shrunk 0 time(s)'],
  'split-fake': ['Counterexample: [0,2]', '1 !== 2'],
  'overlaps-model': ['Counterexample: [{"startHour":19,"hours":1},{"startHour":18,"hours":2}]', 'false !== true'],
  'too-many-discards': ['too many pre-condition failures', 'Ran 0 time(s)'],
  differential: ['Counterexample: [-1]', "S/ 0.-1", "S/ -0.01"],
  'parse-range': ['Counterexample: [""]', "Cannot read properties of undefined (reading 'trim')"],
  'window-readme': ['false !== true'],
};

describe('las demostraciones fallan como dice el capítulo', () => {
  for (const [file, fragments] of Object.entries(expected)) {
    test(file, () => {
      const { status, output } = runDemo(file);
      assert.notEqual(status, 0);
      for (const fragment of fragments) assert.ok(output.includes(fragment), `falta "${fragment}" en:\n${output}`);
    });
  }

  test('en overlaps-model, los dos ejemplos de Kallpa pasan y solo falla el modelo', () => {
    const { output } = runDemo('overlaps-model');
    assert.match(output, /✔ los dos ejemplos de test\/booking.test.ts pasan/);
    assert.match(output, /✖ coincide con el modelo/);
  });
});

import assert from 'node:assert/strict';
import { test } from 'node:test';
import { fuzzBookings, looseBody, shapedBody } from './fuzz-bookings.ts';

test('con valores de cualquier tipo casi todo se queda en la validación, sin 500', async () => {
  const counts = await fuzzBookings(looseBody, 300);
  assert.ok((counts['400 VALIDATION_ERROR'] ?? 0) >= 295, JSON.stringify(counts));
});

test('con los tipos correctos llega a las reglas del negocio y a crear reservas, sin 500', async () => {
  const counts = await fuzzBookings(shapedBody, 1000);
  assert.ok(Object.keys(counts).length >= 6, JSON.stringify(counts));
  assert.ok((counts['200 reserva creada'] ?? 0) > 0, JSON.stringify(counts));
});

import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { goodDate, hoursDistribution, validDatesAmongStrings, weakDate } from './generators.ts';
import { isValidDate } from '../../kallpa/src/domain/calendar.ts';

test('fc.string() casi nunca da algo con forma de fecha', () => {
  assert.equal(validDatesAmongStrings(100_000), 0);
});

test('los generadores construidos siempre dan fechas con la forma correcta', () => {
  assert.ok(fc.sample(goodDate, { numRuns: 1000 }).every(isValidDate));
});

test('el generador de un mes no pasa de febrero', () => {
  assert.ok(fc.sample(weakDate, { numRuns: 1000 }).every((d) => d < '2026-03-01'));
});

test('el generador del año pasa por los doce meses', () => {
  const months = new Set(fc.sample(goodDate, { numRuns: 5000, seed: 2026 }).map((d) => d.slice(5, 7)));
  assert.equal(months.size, 12);
});

test('las tres duraciones aparecen', () => {
  const counts = hoursDistribution(1000);
  assert.ok(counts[1] > 0 && counts[2] > 0 && counts[3] > 0);
});

// Lo que el laboratorio da por hecho sobre su material: los tres diffs aplican a
// la Kallpa publicada, y con ellos sus 40 pruebas siguen pasando. Stryker corre
// con la configuración de la semana.
import assert from 'node:assert/strict';
import { execFileSync, spawnSync } from 'node:child_process';
import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
import { join, resolve } from 'node:path';
import { after, before, describe, test } from 'node:test';
import { CLEAN_ENV } from './clean-env.ts';

const DIFFS = ['agente-1-cruces.diff', 'agente-2-hora-punta.diff', 'agente-3-cancelacion.diff'];
const git = (cwd: string, ...args: string[]) =>
  execFileSync('git', ['-c', 'user.name=Kallpa', '-c', 'user.email=kallpa@example.com', ...args], { cwd, encoding: 'utf8' });

describe('material del laboratorio', () => {
  let dir: string;

  before(() => {
    mkdirSync('build', { recursive: true });
    dir = resolve(mkdtempSync('build/lab-'));
    cpSync('../../kallpa', dir, { recursive: true });
    git(dir, 'init', '-q');
    git(dir, 'add', '-A');
    git(dir, 'commit', '-qm', 'Kallpa publicada');
  });
  after(() => rmSync(dir, { recursive: true, force: true }));

  for (const diff of DIFFS) {
    test(`${diff} se presenta como ilustración, aplica y pasan las 40 pruebas publicadas`, () => {
      const path = resolve(diff);
      const header = readFileSync(path, 'utf8').split('diff --git')[0];
      assert.match(header, /Ilustración escrita para la clase/);
      assert.match(header, /Tarea: /);
      assert.match(header, /Descripción que acompaña el cambio: /);
      git(dir, 'apply', path);
      try {
        const { status, stdout } = spawnSync('node', ['--test', 'test/**/*.test.ts'], { cwd: dir, encoding: 'utf8', env: CLEAN_ENV });
        assert.equal(status, 0, stdout);
        assert.match(stdout, /ℹ pass 40/);
      } finally {
        git(dir, 'checkout', '-q', '--', '.');
      }
    });
  }

  test('stryker.config.json corre sobre la Kallpa publicada y deja su reporte', () => {
    cpSync('stryker.config.json', join(dir, 'stryker.config.json'));
    execFileSync('stryker', ['run'], { cwd: dir, stdio: 'ignore', env: CLEAN_ENV });
    assert.match(readFileSync(join(dir, 'reports/mutation/mutation.html'), 'utf8'), /<html/);
    assert.doesNotMatch(git(dir, 'status', '--porcelain'), /reports|stryker-tmp/);
  });
});

// Corre Stryker sobre los ejemplos de mutation/, en una copia dentro de build/,
// y comprueba los números y los mutantes que cita el capítulo.
import assert from 'node:assert/strict';
import { execFileSync } from 'node:child_process';
import { cpSync, mkdtempSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
import { join } from 'node:path';
import { after, before, describe, test } from 'node:test';
import { CLEAN_ENV } from './clean-env.ts';

type Mutant = { status: string; mutatorName: string; replacement: string; location: { start: { line: number } } };

let dir: string;

function stryker(name: string): Mutant[] {
  execFileSync('stryker', ['run', `stryker.${name}.json`], { cwd: dir, stdio: 'ignore', env: CLEAN_ENV });
  const report = JSON.parse(readFileSync(join(dir, `reports/${name}.json`), 'utf8'));
  return Object.values<{ mutants: Mutant[] }>(report.files).flatMap((file) => file.mutants);
}

const count = (mutants: Mutant[], status: string) => mutants.filter((m) => m.status === status).length;

describe('pruebas de mutación de los ejemplos', () => {
  before(() => {
    mkdirSync('build', { recursive: true });
    dir = mkdtempSync('build/mutation-');
    cpSync('mutation', dir, { recursive: true });
  });
  after(() => rmSync(dir, { recursive: true, force: true }));

  test('la prueba débil cubre todo y solo detecta 3 de 12 mutantes', () => {
    const mutants = stryker('weak');
    assert.equal(mutants.length, 12);
    assert.equal(count(mutants, 'Killed'), 2);
    assert.equal(count(mutants, 'Timeout'), 1);
    assert.equal(count(mutants, 'Survived'), 9);
  });

  test('con valores esperados solo sobrevive el mutante equivalente', () => {
    const mutants = stryker('strong');
    assert.equal(count(mutants, 'Killed'), 10);
    assert.equal(mutants.find((m) => m.status === 'Timeout')?.replacement, 'i--');
    const survivors = mutants.filter((m) => m.status === 'Survived');
    assert.equal(survivors.length, 1);
    assert.equal(survivors[0].replacement, 'voucherCents > totalCents');
  });

  test('el mutante equivalente da lo mismo con céntimos enteros, pero no con Infinity', async () => {
    const { amountDueCents } = await import('./mutation/voucher.ts');
    const mutant = (total: number, voucher: number) => (voucher > total ? 0 : total - voucher);
    for (let total = 0; total <= 300; total++) {
      for (let voucher = 0; voucher <= 300; voucher++) {
        assert.equal(mutant(total, voucher), amountDueCents(total, voucher));
      }
    }
    assert.equal(amountDueCents(Infinity, Infinity), 0);
    assert.ok(Number.isNaN(mutant(Infinity, Infinity)));
  });

  test('el comentario apaga los dos mutantes de igualdad de esa línea, no solo el equivalente', () => {
    const mutants = stryker('marked');
    assert.equal(count(mutants, 'Survived'), 0);
    const ignored = mutants.filter((m) => m.status === 'Ignored').map((m) => m.replacement).sort();
    assert.deepEqual(ignored, ['voucherCents < totalCents', 'voucherCents > totalCents']);
  });

  test('el código con el error de lectura tiene 100 % de mutation score', () => {
    const mutants = stryker('window');
    assert.equal(mutants.length, 10);
    assert.equal(count(mutants, 'Killed'), 10);
  });
});

import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { parseHourRange, parseHourRangeNaive, RangeFormatError } from './parse-range.ts';

test('las dos versiones entienden un pedido normal', () => {
  assert.deepEqual(parseHourRangeNaive('18-20'), { startHour: 18, hours: 2 });
  assert.deepEqual(parseHourRange('18-20'), { startHour: 18, hours: 2 });
});

test('fuzzing: la versión corregida solo falla con RangeFormatError', () => {
  fc.assert(
    fc.property(fc.string(), (text) => {
      try {
        parseHourRange(text);
      } catch (error) {
        assert.ok(error instanceof RangeFormatError);
      }
    }),
    { numRuns: 2000 },
  );
});

test('ida y vuelta: un rango escrito como texto se lee igual', () => {
  fc.assert(
    fc.property(fc.integer({ min: 7, max: 21 }), fc.integer({ min: 1, max: 3 }), (startHour, hours) => {
      const parsed = parseHourRange(`${startHour}-${startHour + hours}`);
      assert.deepEqual(parsed, { startHour, hours });
    }),
  );
});

// Propiedades sobre el dominio de Kallpa, una de cada clase. Salen de las reglas
// del README, no del código. Importan Kallpa sin modificarla.
import assert from 'node:assert/strict';
import { describe, test } from 'node:test';
import fc from 'fast-check';
import { overlaps, type Booking } from '../../kallpa/src/domain/booking.ts';
import { addDays, dayOfWeek, isWeekend } from '../../kallpa/src/domain/calendar.ts';
import { SPORTS, type Court } from '../../kallpa/src/domain/court.ts';
import { MEMBER_PLANS } from '../../kallpa/src/domain/member.ts';
import { formatSoles, hourlyRateCents, quotePriceCents } from '../../kallpa/src/domain/pricing.ts';
import { dailySummary } from '../../kallpa/src/domain/report.ts';
import { formatSolesNoFloat } from './differential.ts';
import { blockArb, sharesAnHour } from './model.ts';

// Fechas válidas de todo 2026, construidas en vez de filtradas.
const dateArb = fc.integer({ min: 0, max: 364 }).map((d) => addDays('2026-01-01', d));
const sportArb = fc.constantFrom(...SPORTS);
const planArb = fc.constantFrom(...MEMBER_PLANS);

describe('invariantes', () => {
  test('una hora nunca cuesta menos de S/ 45 ni tiene fracciones de céntimo', () => {
    fc.assert(
      fc.property(sportArb, planArb, dateArb, fc.integer({ min: 7, max: 21 }), (sport, plan, date, startHour) => {
        const price = quotePriceCents({ sport, plan, date, startHour, hours: 1 });
        assert.ok(Number.isInteger(price));
        // La hora más barata: vóley sin hora punta (S/ 50) con descuento de socio.
        assert.ok(price >= 4500);
      }),
    );
  });

  test('la caja del día suma lo que suma cada cancha', () => {
    fc.assert(
      fc.property(fc.array(bookingArb(), { maxLength: 30 }), (bookings) => {
        const summary = dailySummary('2026-03-10', COURTS, bookings);
        assert.equal(summary.revenueCents, summary.courts.reduce((total, c) => total + c.revenueCents, 0));
        assert.equal(summary.hours, summary.courts.reduce((total, c) => total + c.hours, 0));
      }),
    );
  });
});

describe('ida y vuelta', () => {
  test('sumar n días y restarlos deja la misma fecha', () => {
    fc.assert(
      fc.property(dateArb, fc.integer({ min: -400, max: 400 }), (date, n) => {
        assert.equal(addDays(addDays(date, n), -n), date);
      }),
    );
  });
});

describe('comparación con un modelo', () => {
  test('overlaps dice lo mismo que contar hora por hora', () => {
    fc.assert(
      fc.property(blockArb, blockArb, (a, b) => {
        assert.equal(overlaps(a, b), sharesAnHour(a, b));
      }),
    );
  });
});

describe('relaciones metamórficas', () => {
  test('una semana después, el mismo día de la semana y la misma tarifa', () => {
    fc.assert(
      fc.property(sportArb, dateArb, fc.integer({ min: 7, max: 21 }), (sport, date, hour) => {
        const nextWeek = addDays(date, 7);
        assert.equal(dayOfWeek(nextWeek), dayOfWeek(date));
        assert.equal(hourlyRateCents(sport, nextWeek, hour), hourlyRateCents(sport, date, hour));
      }),
    );
  });

  test('agregar una reserva cancelada no cambia la caja', () => {
    fc.assert(
      fc.property(fc.array(bookingArb(), { maxLength: 30 }), bookingArb(), (bookings, extra) => {
        const before = dailySummary('2026-03-10', COURTS, bookings);
        const after = dailySummary('2026-03-10', COURTS, [...bookings, { ...extra, status: 'cancelled' }]);
        assert.deepEqual(after, before);
      }),
    );
  });
});

describe('equivalencia con otra implementación', () => {
  test('el refactoring de formatSoles da lo mismo con céntimos no negativos', () => {
    fc.assert(
      fc.property(fc.integer({ min: 0, max: 10_000_000 }), (cents) => {
        assert.equal(formatSolesNoFloat(cents), formatSoles(cents));
      }),
    );
  });
});

describe('una regla del README escrita con sus propios números', () => {
  // El sábado 3 de enero de 2026, más k semanas.
  const saturdayArb = fc.integer({ min: 0, max: 51 }).map((k) => addDays('2026-01-03', 7 * k));

  test('un sábado, cualquier hora de fulbito cuesta S/ 112.50', () => {
    fc.assert(
      fc.property(saturdayArb, fc.integer({ min: 7, max: 21 }), (date, hour) => {
        assert.equal(hourlyRateCents('fulbito', date, hour), 11250);
      }),
    );
  });

  test('las fechas del generador son de verdad sábados', () => {
    fc.assert(fc.property(saturdayArb, (date) => dayOfWeek(date) === 6 && isWeekend(date)));
  });
});

// Una reserva cualquiera. Las pruebas solo miran fecha, cancha, horas y precio.
const COURTS: Court[] = [
  { id: 1, name: 'Fulbito 1', sport: 'fulbito' },
  { id: 3, name: 'Vóley', sport: 'voley' },
];

function bookingArb(): fc.Arbitrary<Booking> {
  return fc.record({
    id: fc.nat(),
    courtId: fc.constantFrom(1, 3),
    memberId: fc.constantFrom(1, 2),
    date: fc.constantFrom('2026-03-10', '2026-03-11'),
    startHour: fc.integer({ min: 7, max: 21 }),
    hours: fc.integer({ min: 1, max: 3 }),
    teamName: fc.constant('Los Pumas de Comas'),
    priceCents: fc.integer({ min: 4500, max: 33750 }),
    status: fc.constantFrom('confirmed' as const, 'cancelled' as const),
    createdAt: fc.constant('2026-03-09T15:00:00.000Z'),
    cancelledAt: fc.constant(null),
  });
}

import assert from 'node:assert/strict';
import { describe, test } from 'node:test';
import fc from 'fast-check';
import { splitCents, splitCentsFake, splitCentsNaive } from './split.ts';

const sum = (values: number[]) => values.reduce((total, value) => total + value, 0);

describe('dividir el pago: pruebas de ejemplo', () => {
  test('la versión ingenua pasa los ejemplos fáciles', () => {
    assert.deepEqual(splitCentsNaive(9000, 3), [3000, 3000, 3000]);
    assert.deepEqual(splitCentsNaive(11250, 2), [5625, 5625]);
  });

  test('la versión ingenua también falla con un caso más chico que el que reporta fast-check', () => {
    assert.deepEqual(splitCentsNaive(1, 3), [0, 0, 0]);
    assert.deepEqual(splitCentsNaive(1563, 3), [521, 521, 521]);
    assert.deepEqual(splitCentsNaive(1564, 2), [782, 782]);
  });

  test('la versión hecha a la medida pasa los tres ejemplos', () => {
    assert.deepEqual(splitCentsFake(9000, 3), [3000, 3000, 3000]);
    assert.deepEqual(splitCentsFake(11250, 2), [5625, 5625]);
    assert.deepEqual(splitCentsFake(100, 3), [34, 33, 33]);
  });

  test('la versión correcta también', () => {
    assert.deepEqual(splitCents(9000, 3), [3000, 3000, 3000]);
    assert.deepEqual(splitCents(11250, 2), [5625, 5625]);
    assert.deepEqual(splitCents(100, 3), [34, 33, 33]);
  });
});

describe('dividir el pago: propiedades', () => {
  const total = fc.integer({ min: 0, max: 100_000 });
  const players = fc.integer({ min: 1, max: 22 });

  test('las partes suman el total', () => {
    fc.assert(
      fc.property(total, players, (t, n) => {
        assert.equal(sum(splitCents(t, n)), t);
      }),
    );
  });

  test('hay una parte por jugador y difieren en a lo más un céntimo', () => {
    fc.assert(
      fc.property(total, players, (t, n) => {
        const parts = splitCents(t, n);
        assert.equal(parts.length, n);
        assert.ok(Math.max(...parts) - Math.min(...parts) <= 1);
      }),
    );
  });
});

// Una propiedad que repite la implementación con otras palabras no detecta nada.
import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { addDays, isWeekend } from '../../kallpa/src/domain/calendar.ts';
import { isPeakHour, PEAK_START_HOUR } from '../../kallpa/src/domain/pricing.ts';

const dateArb = fc.integer({ min: 0, max: 364 }).map((d) => addDays('2026-01-01', d));
const hourArb = fc.integer({ min: 7, max: 21 });

test('la tautología pasa con la Kallpa publicada', () => {
  fc.assert(
    fc.property(dateArb, hourArb, (date, hour) => {
      assert.equal(isPeakHour(date, hour), isWeekend(date) || hour >= PEAK_START_HOUR);
    }),
  );
});

test('la misma tautología pasa si alguien cambia la constante a las 12:00', () => {
  const WRONG_START = 12; // el README dice 18:00
  const wrongIsPeakHour = (date: string, hour: number) => isWeekend(date) || hour >= WRONG_START;
  fc.assert(
    fc.property(dateArb, hourArb, (date, hour) => {
      assert.equal(wrongIsPeakHour(date, hour), isWeekend(date) || hour >= WRONG_START);
    }),
  );
});

test('un solo ejemplo sacado del README sí lo detecta', () => {
  const WRONG_START = 12;
  const wrongIsPeakHour = (date: string, hour: number) => isWeekend(date) || hour >= WRONG_START;
  // El martes 10 de marzo de 2026 a las 15:00 no es hora punta.
  assert.equal(isPeakHour('2026-03-10', 15), false);
  assert.notEqual(wrongIsPeakHour('2026-03-10', 15), false);
});

// Falla a propósito: la versión nueva de formatSoles se compara con la anterior
// sobre todos los enteros, y aparece una diferencia que los céntimos positivos
// no muestran.
import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { formatSoles } from '../../../kallpa/src/domain/pricing.ts';
import { formatSolesNoFloat } from '../differential.ts';

test('la versión nueva da lo mismo que la anterior', () => {
  fc.assert(
    fc.property(fc.integer({ min: -100_000, max: 100_000 }), (cents) => {
      assert.equal(formatSolesNoFloat(cents), formatSoles(cents));
    }),
    { seed: 2026 },
  );
});

// Falla a propósito: una versión de overlaps que olvida un caso pasa las dos
// pruebas de ejemplo de Kallpa, pero no la comparación con el modelo.
import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { blockArb, sharesAnHour, type Block } from '../model.ts';

function overlapsForgetful(a: Block, b: Block): boolean {
  return a.startHour <= b.startHour && b.startHour < a.startHour + a.hours;
}

test('los dos ejemplos de test/booking.test.ts pasan', () => {
  assert.equal(overlapsForgetful({ startHour: 18, hours: 2 }, { startHour: 19, hours: 1 }), true);
  assert.equal(overlapsForgetful({ startHour: 18, hours: 2 }, { startHour: 20, hours: 1 }), false);
});

test('coincide con el modelo: comparten alguna hora', () => {
  fc.assert(
    fc.property(blockArb, blockArb, (a, b) => {
      assert.equal(overlapsForgetful(a, b), sharesAnHour(a, b));
    }),
    { seed: 2026 },
  );
});

// Falla a propósito: fuzzing con oráculo implícito. La función puede rechazar
// una entrada con RangeFormatError, pero no puede caerse con otro error.
import { test } from 'node:test';
import fc from 'fast-check';
import { parseHourRangeNaive, RangeFormatError } from '../parse-range.ts';

test('entre lo que entre, no se cae', () => {
  fc.assert(
    fc.property(fc.string(), (text) => {
      try {
        parseHourRangeNaive(text);
      } catch (error) {
        if (!(error instanceof RangeFormatError)) throw error;
      }
    }),
    { seed: 2026 },
  );
});

// Falla a propósito: una función hecha a la medida de los ejemplos no puede
// pasar una propiedad.
import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { splitCentsFake } from '../split.ts';

test('hay una parte por jugador', () => {
  fc.assert(
    fc.property(fc.integer({ min: 0, max: 100_000 }), fc.integer({ min: 1, max: 22 }), (total, players) => {
      assert.equal(splitCentsFake(total, players).length, players);
    }),
    { seed: 2026 },
  );
});

// Falla a propósito: con la semilla y el camino que imprimió fast-check, la
// primera ejecución ya es el contraejemplo reducido.
import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { splitCentsNaive } from '../split.ts';

test('las partes suman el total', () => {
  fc.assert(
    fc.property(fc.integer({ min: 0, max: 100_000 }), fc.integer({ min: 1, max: 22 }), (total, players) => {
      const parts = splitCentsNaive(total, players);
      assert.equal(parts.reduce((a, b) => a + b, 0), total);
    }),
    { seed: 2026, path: '2:1:0:0:0:0:1:0:0:0:0:0:0:0:0:0:0', endOnFailure: true },
  );
});

// Falla a propósito, igual que split-naive.demo.test.ts: con verbose, fast-check
// lista los valores que fallaron mientras reducía el contraejemplo.
import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { splitCentsNaive } from '../split.ts';

test('las partes suman el total', () => {
  fc.assert(
    fc.property(fc.integer({ min: 0, max: 100_000 }), fc.integer({ min: 1, max: 22 }), (total, players) => {
      const parts = splitCentsNaive(total, players);
      assert.equal(parts.reduce((a, b) => a + b, 0), total);
    }),
    { seed: 2026, verbose: 1 },
  );
});

// Falla a propósito: la propiedad encuentra el error de la versión ingenua. La
// semilla está fija solo para que la salida del capítulo se pueda repetir.
import assert from 'node:assert/strict';
import { test } from 'node:test';
import fc from 'fast-check';
import { splitCentsNaive } from '../split.ts';

test('las partes suman el total', () => {
  fc.assert(
    fc.property(fc.integer({ min: 0, max: 100_000 }), fc.integer({ min: 1, max: 22 }), (total, players) => {
      const parts = splitCentsNaive(total, players);
      assert.equal(parts.reduce((a, b) => a + b, 0), total);
    }),
    { seed: 2026 },
  );
});