Certification

{
  "distributions": [
    { "persons": [{ "age": 30 }, { "age": 30 }] }
  ]
}

{
  "distributions": [
    { "persons": [{ "age": 30 }, { "age": 30 }] },
    { "persons": [{ "age": 45 }, { "age": 42 }] }
  ]
}

{
  "distributions": [
    { "persons": [{ "age": 30 }, { "age": 30 }] },
    { "persons": [{ "age": 40 }, { "age": 5 }] }
  ]
}

{
  "accommodation": {
    "combinationKey": "<key from Confirm>",
    "commentToAccommodation": "Adjoining rooms if possible"
  },
  "distributions": [
    {
      "persons": [
        { "name": "Ana", "lastName": "Ruiz", "requestedAge": 30, "courtesyTitle": "MRS", "email": "ana@example.com", "phoneCountryCode": "+34", "phone": "600000000" },
        { "name": "Luis", "lastName": "Ruiz", "requestedAge": 30, "courtesyTitle": "MISTER" }
      ]
    },
    {
      "persons": [
        { "name": "Marta", "lastName": "Gil", "requestedAge": 40, "courtesyTitle": "MS", "email": "marta@example.com" },
        { "name": "Leo", "lastName": "Gil", "requestedAge": 5, "courtesyTitle": "MISTER" }
      ]
    }
  ]
}

// The three certification bookings, run in your test account.
// Env: NAVA_ENV=test, plus your TEST credentials in NAVA_BASE_URL, NAVA_USERNAME,
// NAVA_PASSWORD and NAVA_MICROSITE_ID.
import { describe, expect, it } from 'vitest';

// Real bookings: run only against the sandbox, with test credentials and NAVA_ENV=test.
// Set NAVA_ENV=test only where the test credentials live.
if (process.env.NAVA_ENV !== 'test' || !process.env.NAVA_BASE_URL?.startsWith('https://sandbox.nava.travel/')) {
  throw new Error('These tests make real bookings: run them only against the sandbox, with test credentials and NAVA_ENV=test');
}
const BASE = process.env.NAVA_BASE_URL!;

// Future dates only: a search for past dates returns nothing.
const day = (n: number) => new Date(Date.now() + n * 86_400_000).toISOString().slice(0, 10);
const [checkIn, checkOut] = [day(42), day(46)];

type Person = { requestedAge: number } & Record<string, string | number>;
type Room = { persons: Person[] };

async function call(token: string | null, method: string, path: string, body?: unknown, timeoutMs = 120_000) {
  const res = await fetch(BASE + path, {
    method,
    headers: {
      ...(token ? { 'auth-token': token } : {}),
      'Accept-Encoding': 'gzip',
      ...(body ? { 'Content-Type': 'application/json' } : {}),
    },
    body: body ? JSON.stringify(body) : undefined,
    signal: AbortSignal.timeout(timeoutMs),
  });
  const json = await res.json().catch(() => ({}));
  if (json?.auditData?.authToken) json.auditData.authToken = '[REDACTED]';
  console.log(method, path, res.status, json?.auditData?.traceId); // evidence for the review
  if (!res.ok) throw new Error(`${method} ${path} failed with HTTP ${res.status}`);
  return json;
}

// Quote ages come from the Prebook guests, so the two always match.
const quoteRooms = (rooms: Room[]) =>
  rooms.map((r) => ({ persons: r.persons.map((p) => ({ age: p.requestedAge })) }));

/** One flow on one token: Quote, Confirm, Prebook, Book. */
async function bookFlow(rooms: Room[], orderId: string, fakeBooking?: { status: 'BOOK_ERROR' }) {
  const { token } = await call(null, 'POST', '/authentication/authenticate', {
    username: process.env.NAVA_USERNAME,
    password: process.env.NAVA_PASSWORD,
    micrositeId: process.env.NAVA_MICROSITE_ID,
  });

  const quote = await call(token, 'POST', '/booking/accommodations/quote', {
    checkIn, checkOut, distributions: quoteRooms(rooms), destinationId: 'MAD',
    language: 'EN', sourceMarket: 'AE', tripType: 'ONLY_HOTEL', timeout: 8000,
    filter: { bestCombinations: true, maxCombinations: 4, includeOnRequestOptions: false },
  }, 60_000);
  const hotel = quote.accommodations?.find((a: any) => a.combinations?.length);
  if (!hotel) throw new Error('No availability in the test account for these dates');
  const path = `/booking/accommodations/${hotel.code}`;
  let key = hotel.combinations[0].combinationKey; // key 1

  const confirm = await call(token, 'POST', `${path}/confirm`, { accommodation: { combinationKey: key } });
  if (confirm.warnings?.length) console.log('warnings', confirm.warnings); // your UI asks the guest here
  key = confirm.accommodation.combination.combinationKey; // key 2

  const prebook = await call(token, 'POST', `${path}/prebook`, {
    accommodation: { combinationKey: key },
    distributions: rooms, // same rooms, same order
  });
  key = prebook.accommodation.combination.combinationKey; // key 3

  // Book exactly once. A retry, in code or in the test runner, can book twice.
  const booked = await call(token, 'POST', `${path}/book`, {
    accommodation: { combinationKey: key },
    externalReference: orderId,
    ...(fakeBooking ? { fakeBooking } : {}),
  }, 180_000);
  return { token, booked };
}

// Use your application's real status handler here, not a copy.
function outcome(status: string) {
  switch (status) {
    case 'BOOKED': return 'confirmed';
    case 'RQ': case 'PENDING_BOOK': return 'pending';
    case 'PRICE_ERROR': return 'review';
    case 'BOOK_ERROR': case 'NOT_BOOKED': return 'failed';
    default: return 'review'; // an unknown status is never success
  }
}

// Latin-script names. Match the fields to what requiredField asks for in your test account.
const ana = { name: 'Ana', lastName: 'Ruiz', requestedAge: 30, courtesyTitle: 'MRS',
  email: 'ana@example.com', phoneCountryCode: '+34', phone: '600000000' };
const luis = { name: 'Luis', lastName: 'Ruiz', requestedAge: 30, courtesyTitle: 'MISTER' };
const omar = { name: 'Omar', lastName: 'Haddad', requestedAge: 45, courtesyTitle: 'MISTER', email: 'omar@example.com' };
const sara = { name: 'Sara', lastName: 'Haddad', requestedAge: 42, courtesyTitle: 'MRS' };
const marta = { name: 'Marta', lastName: 'Gil', requestedAge: 40, courtesyTitle: 'MS', email: 'marta@example.com' };
const leo = { name: 'Leo', lastName: 'Gil', requestedAge: 5, courtesyTitle: 'MISTER' };

// retry: 0 on purpose. A retried test books again.
describe('certification bookings (test account)', { timeout: 300_000, retry: 0 }, () => {
  it.each([
    ['1 room, 2 adults', [{ persons: [ana, luis] }]],
    ['2 rooms', [{ persons: [ana, luis] }, { persons: [omar, sara] }]],
    ['adults and children', [{ persons: [ana, luis] }, { persons: [marta, leo] }]],
  ] as [string, Room[]][])('%s', async (_name, rooms) => {
    const orderId = `CERT-${Date.now()}`; // in production, save it before Book
    const { token, booked } = await bookFlow(rooms, orderId);

    // Test suppliers may not answer like real ones. If this fails, keep the output and
    // ask your Nava account manager how the test suppliers respond.
    expect(outcome(booked.status), `Book returned ${booked.status}`).toBe('confirmed');
    expect(booked.distributions).toHaveLength(rooms.length);

    // Read it back with booking detail (GET). Don't use Refresh here: it calls the supplier.
    const detail = await call(token, 'GET',
      `/booking/${booked.bookingReference}/accommodations/${booked.accommodation.bookingReference}`);
    expect(detail.externalReference).toBe(orderId);
  });

  it('sends a failed Book down the failure path', async () => {
    // fakeBooking is not saved, so make no post-booking calls on it.
    const { booked } = await bookFlow([{ persons: [ana, luis] }], `CERT-FAIL-${Date.now()}`, { status: 'BOOK_ERROR' });
    expect(outcome(booked.status)).toBe('failed'); // BOOK_ERROR or NOT_BOOKED at booking level
  });
});