// ESM
import { testApiHandler } from 'next-test-api-route-handler'

async function testApiHandler({ requestPatcher, responsePatcher, params, handler, test }: {
  requestPatcher?: (req: IncomingMessage) => void,
  responsePatcher?: (res: ServerResponse) => void,
  params?: Record<string, unknown>,
  handler: (req: NextApiRequest, res: NextApiResponse) => Promise<void>
  test: (obj: { fetch: (init?: RequestInit) => ReturnType<typeof fetch> }) => Promise<void>,
})

import * as UnreliableHandler from '../pages/api/unreliable'
import { testApiHandler } from 'next-test-api-route-handler'
import { shuffle } from 'fast-shuffle'
import array from 'array-range'

import type { WithConfig } from '@ergodark/next-types'

// Import the handler under test from the pages/api directory and respect the
// Next.js config object if it's exported
const unreliableHandler: WithConfig<typeof UnreliableHandler.default> = UnreliableHandler.default;
unreliableHandler.config = UnreliableHandler.config;

it('injects contrived errors at the required rate', async () => {
  expect.hasAssertions();

  // Signal to the endpoint (which is configurable) that there should be 1
  // error among every 10 requests
  process.env.REQUESTS_PER_CONTRIVED_ERROR = '10';

  const expectedReqPerError = parseInt(process.env.REQUESTS_PER_CONTRIVED_ERROR);

  // Returns one of ['GET', 'POST', 'PUT', 'DELETE'] at random
  const getMethod = () => shuffle(['GET', 'POST', 'PUT', 'DELETE'])[0];

  // Returns the status code from a response object
  const getStatus = async (res: Promise<Response>) => (await res).status;

  await testApiHandler({
    handler: unreliableHandler,
    test: async ({ fetch }) => {
      // Run 20 requests with REQUESTS_PER_CONTRIVED_ERROR = '10' and
      // record the results
      const results1 = await Promise.all([
        ...array(expectedReqPerError - 1).map(_ => getStatus(fetch({ method: getMethod() }))),
        getStatus(fetch({ method: getMethod() })),
        ...array(expectedReqPerError - 1).map(_ => getStatus(fetch({ method: getMethod() }))),
        getStatus(fetch({ method: getMethod() }))
      ].map(p => p.then(s => s, _ => null)));

      process.env.REQUESTS_PER_CONTRIVED_ERROR = '0';

      // Run 10 requests with REQUESTS_PER_CONTRIVED_ERROR = '0' and
      // record the results
      const results2 = await Promise.all([
        ...array(expectedReqPerError).map(_ => getStatus(fetch({ method: getMethod() }))),
      ].map(p => p.then(s => s, _ => null)));

      // We expect results1 to be an array with eighteen `200`s and two
      // `555`s in any order

      // https://github.com/jest-community/jest-extended#toincludesamemembersmembers
      // because responses could be received out of order
      expect(results1).toIncludeSameMembers([
        ...array(expectedReqPerError - 1).map(_ => 200),
        555,
        ...array(expectedReqPerError - 1).map(_ => 200),
        555
      ]);

      // We expect results2 to be an array with ten `200`s

      expect(results2).toStrictEqual([
        ...array(expectedReqPerError).map(_ => 200),
      ]);
    }
  });
});

import * as V3FlightsSearchHandler from '../pages/api/v3/flights/search'
import { testApiHandler } from 'next-test-api-route-handler'
import { DUMMY_API_KEY as KEY, getFlightData, RESULT_SIZE } from '../backend'
import array from 'array-range'

import type { WithConfig } from '@ergodark/next-types'

// Import the handler under test from the pages/api directory and respect the
// Next.js config object if it's exported
const v3FlightsSearchHandler: WithConfig<typeof V3FlightsSearchHandler.default> = V3FlightsSearchHandler.default;
v3FlightsSearchHandler.config = V3FlightsSearchHandler.config;

it('returns expected public flights with respect to match', async () => {
  expect.hasAssertions();

  // Get the flight data currently in the test database
  const flights = getFlightData();

  // Take any JSON object and stringify it into a URL-ready string
  const encode = (o: Record<string, unknown>) => encodeURIComponent(JSON.stringify(o));

  // This function will return in order the URIs we're interested in testing
  // against our handler. Query strings are parsed automatically, though we
  // also could have used `params` or `fetch({ ... })` itself instead.
  //
  // Example URI for `https://google.com/search?params=yes` would be
  // `/search?params=yes`
  const genUrl = function*() {
    yield `/?match=${encode({ airline: 'Spirit' })}`; // i.e. we want all the flights matching Spirit airlines!
    yield `/?match=${encode({ type: 'departure' })}`;
    yield `/?match=${encode({ landingAt: 'F1A' })}`;
    yield `/?match=${encode({ seatPrice: 500 })}`;
    yield `/?match=${encode({ seatPrice: { $gt: 500 }})}`;
    yield `/?match=${encode({ seatPrice: { $gte: 500 }})}`;
    yield `/?match=${encode({ seatPrice: { $lt: 500 }})}`;
    yield `/?match=${encode({ seatPrice: { $lte: 500 }})}`;
  }();

  await testApiHandler({
    // Patch the request object to include our dummy URI
    requestPatcher: req => {
      req.url = genUrl.next().value || undefined;
      // Could have done this instead of fetch({ headers: { KEY }}) below:
      // req.headers = { KEY };
    },

    handler: v3FlightsSearchHandler,

    test: async ({ fetch }) => {
      // 8 URLS from genUrl means 8 calls to fetch:
      const responses = await Promise.all(array(8).map(_ => {
        return fetch({ headers: { KEY }}).then(r => r.ok ? r.json() : r.status);
      }));

      // We expect all of the responses to be 200

      expect(responses.some(o => !o?.success)).toBe(false);

      // We expect the array of flights returned to match our
      // expectations given we already know what dummy data will be
      // returned:

      // https://github.com/jest-community/jest-extended#toincludesamemembersmembers
      // because responses could be received out of order
      expect(responses.map(r => r.flights)).toIncludeSameMembers([
        flights.filter(f => f.airline == 'Spirit').slice(0, RESULT_SIZE),
        flights.filter(f => f.type == 'departure').slice(0, RESULT_SIZE),
        flights.filter(f => f.landingAt == 'F1A').slice(0, RESULT_SIZE),
        flights.filter(f => f.seatPrice == 500).slice(0, RESULT_SIZE),
        flights.filter(f => f.seatPrice > 500).slice(0, RESULT_SIZE),
        flights.filter(f => f.seatPrice >= 500).slice(0, RESULT_SIZE),
        flights.filter(f => f.seatPrice < 500).slice(0, RESULT_SIZE),
        flights.filter(f => f.seatPrice <= 500).slice(0, RESULT_SIZE),
      ]);
    }
  });

  // We expect these two to fail with 400 errors

  await testApiHandler({
    handler: v3FlightsSearchHandler,
    requestPatcher: req => { req.url = `/?match=${encode({ ffms: { $eq: 500 }})}` },
    test: async ({ fetch }) => expect((await fetch({ headers: { KEY }})).status).toBe(400)
  });

  await testApiHandler({
    handler: v3FlightsSearchHandler,
    requestPatcher: req => { req.url = `/?match=${encode({ bad: 500 })}` },
    test: async ({ fetch }) => expect((await fetch({ headers: { KEY }})).status).toBe(400)
  });
});