ca-marketplace-scraper/packages/api-server/test/routes.test.ts

import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";

const fetchFacebookItems = mock(() => Promise.resolve([{ title: "item" }]));
const fetchEbayItems = mock(() => Promise.resolve([{ title: "item" }]));
const fetchKijijiItems = mock(() => Promise.resolve([{ title: "item" }]));

mock.module("@marketplace-scrapers/core", () => ({
  fetchFacebookItems,
  fetchEbayItems,
  fetchKijijiItems,
}));

describe("API routes", () => {
  beforeEach(() => {
    fetchFacebookItems.mockReset();
    fetchFacebookItems.mockImplementation(() =>
      Promise.resolve([{ title: "item" }]),
    );
    fetchEbayItems.mockReset();
    fetchEbayItems.mockImplementation(() =>
      Promise.resolve([{ title: "item" }]),
    );
    fetchKijijiItems.mockReset();
    fetchKijijiItems.mockImplementation(() =>
      Promise.resolve([{ title: "item" }]),
    );
  });

  test("facebookRoute ignores cookies query parameter", async () => {
    const { facebookRoute } = await import("../src/routes/facebook");

    await facebookRoute(
      new Request(
        "http://localhost/api/facebook?q=laptop&location=toronto&maxItems=3&cookies=c_user=1",
      ),
    );

    expect(fetchFacebookItems).toHaveBeenCalledWith("laptop", 1, "toronto", 3);
  });

  test("ebayRoute ignores cookies query parameter", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&cookies=s%3D1&buyItNowOnly=true",
      ),
    );

    expect(fetchEbayItems).toHaveBeenCalledWith("laptop", 1, {
      minPrice: undefined,
      maxPrice: undefined,
      strictMode: false,
      exclusions: [],
      keywords: ["laptop"],
      buyItNowOnly: true,
      canadaOnly: true,
    });
  });

  test("kijijiRoute passes cookies query parameter", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&cookies=s%3D1&maxPages=3",
      ),
    );

    expect(fetchKijijiItems).toHaveBeenCalledWith(
      "laptop",
      4,
      "https://www.kijiji.ca",
      {
        location: undefined,
        category: undefined,
        keywords: undefined,
        sortBy: undefined,
        sortOrder: undefined,
        maxPages: 3,
        priceMin: undefined,
        priceMax: undefined,
        cookies: "s=1",
      },
      {},
    );
  });

  test("facebookRoute forwards unstableFilter=true to core", async () => {
    const { facebookRoute } = await import("../src/routes/facebook");

    fetchFacebookItems.mockImplementation(() =>
      Promise.resolve({
        results: [{ title: "item" }],
        unstableResults: [],
      }),
    );

    await facebookRoute(
      new Request(
        "http://localhost/api/facebook?q=laptop&location=toronto&maxItems=3&unstableFilter=true",
      ),
    );

    expect(fetchFacebookItems).toHaveBeenCalledWith("laptop", 1, "toronto", 3, {
      hideUnstableResults: true,
    });
  });

  test("ebayRoute forwards unstableFilter=true to core", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    fetchEbayItems.mockImplementation(() =>
      Promise.resolve({
        results: [{ title: "item" }],
        unstableResults: [],
      }),
    );

    await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&buyItNowOnly=true&unstableFilter=true",
      ),
    );

    expect(fetchEbayItems).toHaveBeenCalledWith("laptop", 1, {
      minPrice: undefined,
      maxPrice: undefined,
      strictMode: false,
      exclusions: [],
      keywords: ["laptop"],
      buyItNowOnly: true,
      canadaOnly: true,
    }, {
      hideUnstableResults: true,
    });
  });

  test("kijijiRoute forwards unstableFilter=true to core", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    fetchKijijiItems.mockImplementation(() =>
      Promise.resolve({
        results: [{ title: "item" }],
        unstableResults: [],
      }),
    );

    await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&maxPages=5&unstableFilter=true",
      ),
    );

    expect(fetchKijijiItems).toHaveBeenCalledWith(
      "laptop",
      4,
      "https://www.kijiji.ca",
      {
        location: undefined,
        category: undefined,
        keywords: undefined,
        sortBy: undefined,
        sortOrder: undefined,
        maxPages: 5,
        priceMin: undefined,
        priceMax: undefined,
        cookies: undefined,
      },
      {},
      {
        hideUnstableResults: true,
      },
    );
  });

  test("facebookRoute does not forward unstableFilter when absent", async () => {
    const { facebookRoute } = await import("../src/routes/facebook");

    await facebookRoute(
      new Request(
        "http://localhost/api/facebook?q=laptop&location=toronto&maxItems=3",
      ),
    );

    expect(fetchFacebookItems).toHaveBeenCalledWith("laptop", 1, "toronto", 3);
  });

  test("facebookRoute does not forward unstableFilter when false", async () => {
    const { facebookRoute } = await import("../src/routes/facebook");

    await facebookRoute(
      new Request(
        "http://localhost/api/facebook?q=laptop&location=toronto&maxItems=3&unstableFilter=false",
      ),
    );

    expect(fetchFacebookItems).toHaveBeenCalledWith("laptop", 1, "toronto", 3);
  });

  test("ebayRoute does not forward unstableFilter when absent", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&buyItNowOnly=true",
      ),
    );

    expect(fetchEbayItems).toHaveBeenCalledWith("laptop", 1, {
      minPrice: undefined,
      maxPrice: undefined,
      strictMode: false,
      exclusions: [],
      keywords: ["laptop"],
      buyItNowOnly: true,
      canadaOnly: true,
    });
  });

  test("ebayRoute does not forward unstableFilter when false", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&buyItNowOnly=true&unstableFilter=false",
      ),
    );

    expect(fetchEbayItems).toHaveBeenCalledWith("laptop", 1, {
      minPrice: undefined,
      maxPrice: undefined,
      strictMode: false,
      exclusions: [],
      keywords: ["laptop"],
      buyItNowOnly: true,
      canadaOnly: true,
    });
  });

  test("kijijiRoute does not forward unstableFilter when absent", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&maxPages=5",
      ),
    );

    expect(fetchKijijiItems).toHaveBeenCalledWith(
      "laptop",
      4,
      "https://www.kijiji.ca",
      {
        location: undefined,
        category: undefined,
        keywords: undefined,
        sortBy: undefined,
        sortOrder: undefined,
        maxPages: 5,
        priceMin: undefined,
        priceMax: undefined,
        cookies: undefined,
      },
      {},
    );
  });

  test("kijijiRoute does not forward unstableFilter when false", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&maxPages=5&unstableFilter=false",
      ),
    );

    expect(fetchKijijiItems).toHaveBeenCalledWith(
      "laptop",
      4,
      "https://www.kijiji.ca",
      {
        location: undefined,
        category: undefined,
        keywords: undefined,
        sortBy: undefined,
        sortOrder: undefined,
        maxPages: 5,
        priceMin: undefined,
        priceMax: undefined,
        cookies: undefined,
      },
      {},
    );
  });

  test("facebookRoute returns bucket shape when unstableFilter is enabled", async () => {
    const { facebookRoute } = await import("../src/routes/facebook");

    fetchFacebookItems.mockImplementation(() =>
      Promise.resolve({
        results: [{ title: "a" }],
        unstableResults: [{ title: "b" }],
      }),
    );

    const response = await facebookRoute(
      new Request(
        "http://localhost/api/facebook?q=laptop&location=toronto&maxItems=3&unstableFilter=true",
      ),
    );

    const body = await response.json();
    expect(body.results).toHaveLength(1);
    expect(body.unstableResults).toHaveLength(1);
    expect(body.results[0].title).toBe("a");
    expect(body.unstableResults[0].title).toBe("b");
  });

  test("kijijiRoute returns bucket shape when unstableFilter is enabled", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    fetchKijijiItems.mockImplementation(() =>
      Promise.resolve({
        results: [{ title: "a" }],
        unstableResults: [{ title: "b" }],
      }),
    );

    const response = await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&maxPages=5&unstableFilter=true",
      ),
    );

    const body = await response.json();
    expect(body.results).toHaveLength(1);
    expect(body.unstableResults).toHaveLength(1);
    expect(body.results[0].title).toBe("a");
    expect(body.unstableResults[0].title).toBe("b");
  });

  test("facebookRoute returns 404 when unstable results are empty", async () => {
    const { facebookRoute } = await import("../src/routes/facebook");

    fetchFacebookItems.mockImplementation(() =>
      Promise.resolve({
        results: [],
        unstableResults: [],
      }),
    );

    const response = await facebookRoute(
      new Request(
        "http://localhost/api/facebook?q=laptop&location=toronto&maxItems=3&unstableFilter=true",
      ),
    );

    expect(response.status).toBe(404);
    const body = await response.json();
    expect(body.message).toBe("Search didn't return any results!");
  });

  test("kijijiRoute returns 404 when unstable results are empty", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    fetchKijijiItems.mockImplementation(() =>
      Promise.resolve({
        results: [],
        unstableResults: [],
      }),
    );

    const response = await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&maxPages=5&unstableFilter=true",
      ),
    );

    expect(response.status).toBe(404);
    const body = await response.json();
    expect(body.message).toBe("Search didn't return any results!");
  });

  test("ebayRoute respects maxItems=0 in default mode", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    fetchEbayItems.mockImplementation(() =>
      Promise.resolve([{ title: "a" }, { title: "b" }]),
    );

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&maxItems=0",
      ),
    );

    const body = await response.json();
    expect(body).toHaveLength(0);
  });

  test("ebayRoute passes through scraper payload unchanged in unstable mode", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    fetchEbayItems.mockImplementation(() =>
      Promise.resolve({
        results: [{ title: "a" }, { title: "b" }, { title: "c" }],
        unstableResults: [{ title: "d" }, { title: "e" }],
      }),
    );

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&unstableFilter=true&maxItems=4",
      ),
    );

    const body = await response.json();
    expect(body.results).toHaveLength(3);
    expect(body.unstableResults).toHaveLength(2);
    expect(body.results[0].title).toBe("a");
    expect(body.unstableResults[0].title).toBe("d");
  });

  test("ebayRoute returns 404 when unstable results are empty", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    fetchEbayItems.mockImplementation(() =>
      Promise.resolve({
        results: [],
        unstableResults: [],
      }),
    );

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&unstableFilter=true",
      ),
    );

    expect(response.status).toBe(404);
    const body = await response.json();
    expect(body.message).toBe("Search didn't return any results!");
  });

  test("ebayRoute returns 400 for invalid maxItems", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&maxItems=abc",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid maxItems parameter");
  });

  test("facebookRoute returns 400 for invalid maxItems", async () => {
    const { facebookRoute } = await import("../src/routes/facebook");

    const response = await facebookRoute(
      new Request(
        "http://localhost/api/facebook?q=laptop&maxItems=abc",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid maxItems parameter");
  });

  test("ebayRoute returns 400 for invalid minPrice", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&minPrice=abc",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid minPrice parameter");
  });

  test("ebayRoute returns 400 for invalid maxPrice", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&maxPrice=abc",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid maxPrice parameter");
  });

  test("kijijiRoute returns 400 for invalid maxPages", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    const response = await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&maxPages=abc",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid maxPages parameter");
  });

  test("kijijiRoute returns 400 for invalid priceMin", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    const response = await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&priceMin=abc",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid priceMin parameter");
  });

  test("kijijiRoute returns 400 for invalid priceMax", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    const response = await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&priceMax=abc",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid priceMax parameter");
  });

  test("facebookRoute returns 400 for negative maxItems", async () => {
    const { facebookRoute } = await import("../src/routes/facebook");

    const response = await facebookRoute(
      new Request(
        "http://localhost/api/facebook?q=laptop&maxItems=-1",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid maxItems parameter");
  });

  test("ebayRoute returns 400 for negative maxItems", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&maxItems=-1",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid maxItems parameter");
  });

  test("ebayRoute returns 400 for negative minPrice", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&minPrice=-5",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid minPrice parameter");
  });

  test("ebayRoute returns 400 for negative maxPrice", async () => {
    const { ebayRoute } = await import("../src/routes/ebay");

    const response = await ebayRoute(
      new Request(
        "http://localhost/api/ebay?q=laptop&maxPrice=-10",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid maxPrice parameter");
  });

  test("kijijiRoute returns 400 for negative maxPages", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    const response = await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&maxPages=-2",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid maxPages parameter");
  });

  test("kijijiRoute returns 400 for negative priceMin", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    const response = await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&priceMin=-5",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid priceMin parameter");
  });

  test("kijijiRoute returns 400 for negative priceMax", async () => {
    const { kijijiRoute } = await import("../src/routes/kijiji");

    const response = await kijijiRoute(
      new Request(
        "http://localhost/api/kijiji?q=laptop&priceMax=-10",
      ),
    );

    expect(response.status).toBe(400);
    const body = await response.json();
    expect(body.message).toBe("Invalid priceMax parameter");
  });
});