835 lines
25 KiB
TypeScript
835 lines
25 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
|
|
import {
|
|
extractFacebookItemData,
|
|
extractFacebookMarketplaceData,
|
|
fetchFacebookItem,
|
|
formatCentsToCurrency,
|
|
formatCookiesForHeader,
|
|
loadFacebookCookies,
|
|
parseFacebookAds,
|
|
parseFacebookCookieString,
|
|
parseFacebookItem,
|
|
} from "../src/facebook";
|
|
|
|
// Mock fetch globally
|
|
const originalFetch = global.fetch;
|
|
|
|
describe("Facebook Marketplace Scraper Core Tests", () => {
|
|
beforeEach(() => {
|
|
global.fetch = mock(() => {
|
|
throw new Error("fetch should be mocked in individual tests");
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
global.fetch = originalFetch;
|
|
});
|
|
|
|
describe("Cookie Parsing", () => {
|
|
describe("parseFacebookCookieString", () => {
|
|
test("should parse valid cookie string", () => {
|
|
const cookieString = "c_user=123456789; xs=abcdef123456; fr=xyz789";
|
|
const result = parseFacebookCookieString(cookieString);
|
|
|
|
expect(result).toHaveLength(3);
|
|
expect(result[0]).toEqual({
|
|
name: "c_user",
|
|
value: "123456789",
|
|
domain: ".facebook.com",
|
|
path: "/",
|
|
secure: true,
|
|
httpOnly: false,
|
|
sameSite: "lax",
|
|
expirationDate: undefined,
|
|
});
|
|
expect(result[1]).toEqual({
|
|
name: "xs",
|
|
value: "abcdef123456",
|
|
domain: ".facebook.com",
|
|
path: "/",
|
|
secure: true,
|
|
httpOnly: false,
|
|
sameSite: "lax",
|
|
expirationDate: undefined,
|
|
});
|
|
});
|
|
|
|
test("should handle URL-encoded values", () => {
|
|
const cookieString = "c_user=123%2B456; xs=abc%3Ddef";
|
|
const result = parseFacebookCookieString(cookieString);
|
|
|
|
expect(result[0].value).toBe("123+456");
|
|
expect(result[1].value).toBe("abc=def");
|
|
});
|
|
|
|
test("should filter out malformed cookies", () => {
|
|
const cookieString = "c_user=123; invalid; xs=abc; =empty";
|
|
const result = parseFacebookCookieString(cookieString);
|
|
|
|
expect(result).toHaveLength(2);
|
|
expect(result.map((c) => c.name)).toEqual(["c_user", "xs"]);
|
|
});
|
|
|
|
test("should handle empty input", () => {
|
|
expect(parseFacebookCookieString("")).toEqual([]);
|
|
expect(parseFacebookCookieString(" ")).toEqual([]);
|
|
});
|
|
|
|
test("should handle extra whitespace", () => {
|
|
const cookieString = " c_user = 123 ; xs=abc ";
|
|
const result = parseFacebookCookieString(cookieString);
|
|
|
|
expect(result).toHaveLength(2);
|
|
expect(result[0].name).toBe("c_user");
|
|
expect(result[0].value).toBe("123");
|
|
expect(result[1].name).toBe("xs");
|
|
expect(result[1].value).toBe("abc");
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Facebook Item Fetching", () => {
|
|
describe("fetchFacebookItem", () => {
|
|
const mockCookies = JSON.stringify([
|
|
{ name: "c_user", value: "12345", domain: ".facebook.com" },
|
|
{ name: "xs", value: "abc123", domain: ".facebook.com" },
|
|
]);
|
|
|
|
test("should handle authentication errors", async () => {
|
|
global.fetch = mock(() =>
|
|
Promise.resolve({
|
|
ok: false,
|
|
status: 401,
|
|
text: () => Promise.resolve("Authentication required"),
|
|
headers: {
|
|
get: () => null,
|
|
},
|
|
}),
|
|
);
|
|
|
|
const result = await fetchFacebookItem("123", mockCookies);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should handle item not found", async () => {
|
|
global.fetch = mock(() =>
|
|
Promise.resolve({
|
|
ok: false,
|
|
status: 404,
|
|
text: () => Promise.resolve("Not found"),
|
|
headers: {
|
|
get: () => null,
|
|
},
|
|
}),
|
|
);
|
|
|
|
const result = await fetchFacebookItem("nonexistent", mockCookies);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should handle rate limiting", async () => {
|
|
let attempts = 0;
|
|
global.fetch = mock(() => {
|
|
attempts++;
|
|
if (attempts === 1) {
|
|
return Promise.resolve({
|
|
ok: false,
|
|
status: 429,
|
|
headers: {
|
|
get: (header: string) => {
|
|
if (header === "X-RateLimit-Reset") return "1";
|
|
return null;
|
|
},
|
|
},
|
|
text: () => Promise.resolve("Rate limited"),
|
|
});
|
|
}
|
|
const mockData = {
|
|
require: [
|
|
[
|
|
null,
|
|
null,
|
|
null,
|
|
{
|
|
__bbox: {
|
|
result: {
|
|
data: {
|
|
viewer: {
|
|
marketplace_product_details_page: {
|
|
target: {
|
|
id: "123",
|
|
__typename: "GroupCommerceProductItem",
|
|
marketplace_listing_title: "Test Item",
|
|
is_live: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
],
|
|
};
|
|
return Promise.resolve({
|
|
ok: true,
|
|
text: () =>
|
|
Promise.resolve(
|
|
`<html><body><script>${JSON.stringify(mockData)}</script></body></html>`,
|
|
),
|
|
headers: {
|
|
get: () => null,
|
|
},
|
|
});
|
|
});
|
|
|
|
const result = await fetchFacebookItem("123", mockCookies);
|
|
expect(attempts).toBe(2);
|
|
// Should eventually succeed after retry
|
|
});
|
|
|
|
test("should handle sold items", async () => {
|
|
const mockData = {
|
|
require: [
|
|
[
|
|
null,
|
|
null,
|
|
null,
|
|
{
|
|
__bbox: {
|
|
result: {
|
|
data: {
|
|
viewer: {
|
|
marketplace_product_details_page: {
|
|
target: {
|
|
id: "456",
|
|
__typename: "GroupCommerceProductItem",
|
|
marketplace_listing_title: "Sold Item",
|
|
is_sold: true,
|
|
is_live: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
],
|
|
};
|
|
|
|
global.fetch = mock(() =>
|
|
Promise.resolve({
|
|
ok: true,
|
|
text: () =>
|
|
Promise.resolve(
|
|
`<html><body><script>${JSON.stringify(mockData)}</script></body></html>`,
|
|
),
|
|
headers: {
|
|
get: () => null,
|
|
},
|
|
}),
|
|
);
|
|
|
|
const result = await fetchFacebookItem("456", mockCookies);
|
|
expect(result?.listingStatus).toBe("SOLD");
|
|
});
|
|
|
|
test("should handle missing authentication cookies", async () => {
|
|
// Use a test-specific cookie file that doesn't exist
|
|
const testCookiePath = "./cookies/facebook-test.json";
|
|
|
|
// Test with no cookies available (test file doesn't exist)
|
|
await expect(
|
|
fetchFacebookItem("123", undefined, testCookiePath),
|
|
).rejects.toThrow("No valid Facebook cookies found");
|
|
});
|
|
|
|
test("should handle successful item extraction", async () => {
|
|
const mockData = {
|
|
require: [
|
|
[
|
|
null,
|
|
null,
|
|
null,
|
|
{
|
|
__bbox: {
|
|
result: {
|
|
data: {
|
|
viewer: {
|
|
marketplace_product_details_page: {
|
|
target: {
|
|
id: "789",
|
|
__typename: "GroupCommerceProductItem",
|
|
marketplace_listing_title: "Working Item",
|
|
formatted_price: { text: "$299.00" },
|
|
listing_price: {
|
|
amount: "299.00",
|
|
currency: "CAD",
|
|
},
|
|
is_live: true,
|
|
creation_time: 1640995200,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
],
|
|
};
|
|
|
|
global.fetch = mock(() =>
|
|
Promise.resolve({
|
|
ok: true,
|
|
text: () =>
|
|
Promise.resolve(
|
|
`<html><body><script>${JSON.stringify(mockData)}</script></body></html>`,
|
|
),
|
|
headers: {
|
|
get: () => null,
|
|
},
|
|
}),
|
|
);
|
|
|
|
const result = await fetchFacebookItem("789", mockCookies);
|
|
expect(result).not.toBeNull();
|
|
expect(result?.title).toBe("Working Item");
|
|
expect(result?.listingPrice?.amountFormatted).toBe("$299.00");
|
|
expect(result?.listingStatus).toBe("ACTIVE");
|
|
});
|
|
|
|
test("should handle server errors", async () => {
|
|
global.fetch = mock(() =>
|
|
Promise.resolve({
|
|
ok: false,
|
|
status: 500,
|
|
text: () => Promise.resolve("Internal Server Error"),
|
|
headers: {
|
|
get: () => null,
|
|
},
|
|
}),
|
|
);
|
|
|
|
const result = await fetchFacebookItem("error", mockCookies);
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Data Extraction", () => {
|
|
describe("extractFacebookItemData", () => {
|
|
test("should extract item data from standard require structure", () => {
|
|
const mockItemData = {
|
|
id: "123456",
|
|
__typename: "GroupCommerceProductItem",
|
|
marketplace_listing_title: "Test Item",
|
|
formatted_price: { text: "$100.00" },
|
|
listing_price: { amount: "100.00", currency: "CAD" },
|
|
is_live: true,
|
|
};
|
|
const mockData = {
|
|
require: [
|
|
[
|
|
null,
|
|
null,
|
|
null,
|
|
{
|
|
__bbox: {
|
|
result: {
|
|
data: {
|
|
viewer: {
|
|
marketplace_product_details_page: {
|
|
target: mockItemData,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
],
|
|
};
|
|
const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;
|
|
|
|
const result = extractFacebookItemData(html);
|
|
expect(result).not.toBeNull();
|
|
expect(result?.id).toBe("123456");
|
|
expect(result?.marketplace_listing_title).toBe("Test Item");
|
|
});
|
|
|
|
test("should handle missing item data", () => {
|
|
const mockData = {
|
|
require: [
|
|
[
|
|
null,
|
|
null,
|
|
null,
|
|
{
|
|
__bbox: {
|
|
result: {
|
|
data: {
|
|
viewer: {
|
|
marketplace_product_details_page: {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
],
|
|
};
|
|
const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;
|
|
|
|
const result = extractFacebookItemData(html);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should handle malformed HTML", () => {
|
|
const result = extractFacebookItemData(
|
|
"<html><body>Invalid HTML</body></html>",
|
|
);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should handle invalid JSON in script tags", () => {
|
|
const html =
|
|
"<html><body><script>{invalid: json}</script></body></html>";
|
|
const result = extractFacebookItemData(html);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
test("should extract item with vehicle data", () => {
|
|
const mockVehicleItem = {
|
|
id: "789",
|
|
__typename: "GroupCommerceProductItem",
|
|
marketplace_listing_title: "2006 Honda Civic",
|
|
formatted_price: { text: "$5,000" },
|
|
listing_price: { amount: "5000.00", currency: "CAD" },
|
|
vehicle_make_display_name: "Honda",
|
|
vehicle_model_display_name: "Civic",
|
|
vehicle_odometer_data: { unit: "KILOMETERS", value: 150000 },
|
|
vehicle_transmission_type: "AUTOMATIC",
|
|
is_live: true,
|
|
};
|
|
const mockData = {
|
|
require: [
|
|
[
|
|
null,
|
|
null,
|
|
null,
|
|
{
|
|
__bbox: {
|
|
result: {
|
|
data: {
|
|
viewer: {
|
|
marketplace_product_details_page: {
|
|
target: mockVehicleItem,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
],
|
|
};
|
|
const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;
|
|
|
|
const result = extractFacebookItemData(html);
|
|
expect(result).not.toBeNull();
|
|
expect(result?.vehicle_make_display_name).toBe("Honda");
|
|
expect(result?.vehicle_odometer_data?.value).toBe(150000);
|
|
});
|
|
});
|
|
|
|
describe("extractFacebookMarketplaceData", () => {
|
|
test("should extract search results from marketplace data", () => {
|
|
const mockMarketplaceData = {
|
|
feed_units: {
|
|
edges: [
|
|
{
|
|
node: {
|
|
listing: {
|
|
id: "1",
|
|
marketplace_listing_title: "Item 1",
|
|
listing_price: { amount: "10.00", currency: "CAD" },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
node: {
|
|
listing: {
|
|
id: "2",
|
|
marketplace_listing_title: "Item 2",
|
|
listing_price: { amount: "20.00", currency: "CAD" },
|
|
},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
};
|
|
const mockData = {
|
|
require: [
|
|
[
|
|
null,
|
|
null,
|
|
null,
|
|
{
|
|
__bbox: {
|
|
result: {
|
|
data: {
|
|
marketplace_search: mockMarketplaceData,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
],
|
|
};
|
|
const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;
|
|
|
|
const result = extractFacebookMarketplaceData(html);
|
|
expect(result).not.toBeNull();
|
|
expect(result).toHaveLength(2);
|
|
expect(result?.[0].node.listing.marketplace_listing_title).toBe(
|
|
"Item 1",
|
|
);
|
|
});
|
|
|
|
test("should handle empty search results", () => {
|
|
const mockData = {
|
|
require: [
|
|
[
|
|
null,
|
|
null,
|
|
null,
|
|
{
|
|
__bbox: {
|
|
result: {
|
|
data: {
|
|
marketplace_search: {
|
|
feed_units: { edges: [] },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
],
|
|
};
|
|
const html = `<html><body><script>${JSON.stringify(mockData)}</script></body></html>`;
|
|
|
|
const result = extractFacebookMarketplaceData(html);
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Data Parsing", () => {
|
|
describe("parseFacebookItem", () => {
|
|
test("should parse complete item with all fields", () => {
|
|
const item = {
|
|
id: "123456",
|
|
__typename: "GroupCommerceProductItem" as const,
|
|
marketplace_listing_title: "iPhone 13 Pro",
|
|
redacted_description: { text: "Excellent condition" },
|
|
formatted_price: { text: "$800.00" },
|
|
listing_price: { amount: "800.00", currency: "CAD" },
|
|
location_text: { text: "Toronto, ON" },
|
|
is_live: true,
|
|
creation_time: 1640995200,
|
|
marketplace_listing_seller: {
|
|
id: "seller1",
|
|
name: "John Doe",
|
|
},
|
|
delivery_types: ["IN_PERSON"],
|
|
};
|
|
|
|
const result = parseFacebookItem(item);
|
|
expect(result).not.toBeNull();
|
|
expect(result?.title).toBe("iPhone 13 Pro");
|
|
expect(result?.description).toBe("Excellent condition");
|
|
expect(result?.listingPrice?.amountFormatted).toBe("$800.00");
|
|
expect(result?.listingPrice?.cents).toBe(80000);
|
|
expect(result?.listingPrice?.currency).toBe("CAD");
|
|
expect(result?.address).toBe("Toronto, ON");
|
|
expect(result?.listingStatus).toBe("ACTIVE");
|
|
expect(result?.seller?.name).toBe("John Doe");
|
|
expect(result?.deliveryTypes).toEqual(["IN_PERSON"]);
|
|
});
|
|
|
|
test("should parse FREE items", () => {
|
|
const item = {
|
|
id: "789",
|
|
__typename: "GroupCommerceProductItem" as const,
|
|
marketplace_listing_title: "Free Sofa",
|
|
formatted_price: { text: "FREE" },
|
|
listing_price: { amount: "0.00", currency: "CAD" },
|
|
is_live: true,
|
|
};
|
|
|
|
const result = parseFacebookItem(item);
|
|
expect(result).not.toBeNull();
|
|
expect(result?.title).toBe("Free Sofa");
|
|
expect(result?.listingPrice?.amountFormatted).toBe("FREE");
|
|
expect(result?.listingPrice?.cents).toBe(0);
|
|
});
|
|
|
|
test("should handle missing optional fields", () => {
|
|
const item = {
|
|
id: "456",
|
|
__typename: "GroupCommerceProductItem" as const,
|
|
marketplace_listing_title: "Minimal Item",
|
|
};
|
|
|
|
const result = parseFacebookItem(item);
|
|
expect(result).not.toBeNull();
|
|
expect(result?.title).toBe("Minimal Item");
|
|
expect(result?.description).toBeUndefined();
|
|
expect(result?.seller).toBeUndefined();
|
|
});
|
|
|
|
test("should identify vehicle listings", () => {
|
|
const vehicleItem = {
|
|
id: "999",
|
|
__typename: "GroupCommerceProductItem" as const,
|
|
marketplace_listing_title: "2012 Mazda 3",
|
|
formatted_price: { text: "$8,000" },
|
|
listing_price: { amount: "8000.00", currency: "CAD" },
|
|
vehicle_make_display_name: "Mazda",
|
|
vehicle_model_display_name: "3",
|
|
is_live: true,
|
|
};
|
|
|
|
const result = parseFacebookItem(vehicleItem);
|
|
expect(result?.listingType).toBe("vehicle");
|
|
});
|
|
|
|
test("should handle different listing statuses", () => {
|
|
const soldItem = {
|
|
id: "111",
|
|
__typename: "GroupCommerceProductItem" as const,
|
|
marketplace_listing_title: "Sold Item",
|
|
is_sold: true,
|
|
is_live: false,
|
|
};
|
|
|
|
const pendingItem = {
|
|
id: "222",
|
|
__typename: "GroupCommerceProductItem" as const,
|
|
marketplace_listing_title: "Pending Item",
|
|
is_pending: true,
|
|
is_live: true,
|
|
};
|
|
|
|
const hiddenItem = {
|
|
id: "333",
|
|
__typename: "GroupCommerceProductItem" as const,
|
|
marketplace_listing_title: "Hidden Item",
|
|
is_hidden: true,
|
|
is_live: false,
|
|
};
|
|
|
|
expect(parseFacebookItem(soldItem)?.listingStatus).toBe("SOLD");
|
|
expect(parseFacebookItem(pendingItem)?.listingStatus).toBe("PENDING");
|
|
expect(parseFacebookItem(hiddenItem)?.listingStatus).toBe("HIDDEN");
|
|
});
|
|
|
|
test("should return null for items without title", () => {
|
|
const invalidItem = {
|
|
id: "invalid",
|
|
__typename: "GroupCommerceProductItem" as const,
|
|
is_live: true,
|
|
};
|
|
|
|
const result = parseFacebookItem(invalidItem);
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("parseFacebookAds", () => {
|
|
test("should parse search result ads", () => {
|
|
const ads = [
|
|
{
|
|
node: {
|
|
listing: {
|
|
id: "1",
|
|
marketplace_listing_title: "Ad 1",
|
|
listing_price: {
|
|
amount: "50.00",
|
|
formatted_amount: "$50.00",
|
|
currency: "CAD",
|
|
},
|
|
location: {
|
|
reverse_geocode: { city_page: { display_name: "Toronto" } },
|
|
},
|
|
creation_time: 1640995200,
|
|
is_live: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
node: {
|
|
listing: {
|
|
id: "2",
|
|
marketplace_listing_title: "Ad 2",
|
|
listing_price: {
|
|
amount: "75.00",
|
|
formatted_amount: "$75.00",
|
|
currency: "CAD",
|
|
},
|
|
location: {
|
|
reverse_geocode: { city_page: { display_name: "Ottawa" } },
|
|
},
|
|
creation_time: 1640995300,
|
|
is_live: true,
|
|
},
|
|
},
|
|
},
|
|
];
|
|
|
|
const results = parseFacebookAds(ads);
|
|
expect(results).toHaveLength(2);
|
|
expect(results[0].title).toBe("Ad 1");
|
|
expect(results[0].listingPrice?.cents).toBe(5000);
|
|
expect(results[0].address).toBe("Toronto");
|
|
expect(results[1].title).toBe("Ad 2");
|
|
expect(results[1].address).toBe("Ottawa");
|
|
});
|
|
|
|
test("should filter out ads without price", () => {
|
|
const ads = [
|
|
{
|
|
node: {
|
|
listing: {
|
|
id: "1",
|
|
marketplace_listing_title: "With Price",
|
|
listing_price: {
|
|
amount: "100.00",
|
|
formatted_amount: "$100.00",
|
|
currency: "CAD",
|
|
},
|
|
is_live: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
node: {
|
|
listing: {
|
|
id: "2",
|
|
marketplace_listing_title: "No Price",
|
|
is_live: true,
|
|
},
|
|
},
|
|
},
|
|
];
|
|
|
|
const results = parseFacebookAds(ads);
|
|
expect(results).toHaveLength(1);
|
|
expect(results[0].title).toBe("With Price");
|
|
});
|
|
|
|
test("should handle malformed ads gracefully", () => {
|
|
const ads = [
|
|
{
|
|
node: {
|
|
listing: {
|
|
id: "1",
|
|
marketplace_listing_title: "Valid Ad",
|
|
listing_price: {
|
|
amount: "50.00",
|
|
formatted_amount: "$50.00",
|
|
currency: "CAD",
|
|
},
|
|
is_live: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
node: {
|
|
// Missing listing
|
|
},
|
|
} as { node: { listing?: unknown } },
|
|
];
|
|
|
|
const results = parseFacebookAds(ads);
|
|
expect(results).toHaveLength(1);
|
|
expect(results[0].title).toBe("Valid Ad");
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Utility Functions", () => {
|
|
describe("formatCentsToCurrency", () => {
|
|
test("should format cents to currency string", () => {
|
|
expect(formatCentsToCurrency(100)).toBe("$1.00");
|
|
expect(formatCentsToCurrency(1000)).toBe("$10.00");
|
|
expect(formatCentsToCurrency(9999)).toBe("$99.99");
|
|
expect(formatCentsToCurrency(123456)).toBe("$1,234.56");
|
|
});
|
|
|
|
test("should handle string inputs", () => {
|
|
expect(formatCentsToCurrency("100")).toBe("$1.00");
|
|
expect(formatCentsToCurrency("1000")).toBe("$10.00");
|
|
});
|
|
|
|
test("should handle zero", () => {
|
|
expect(formatCentsToCurrency(0)).toBe("$0.00");
|
|
});
|
|
|
|
test("should handle null and undefined", () => {
|
|
expect(formatCentsToCurrency(null)).toBe("");
|
|
expect(formatCentsToCurrency(undefined)).toBe("");
|
|
});
|
|
|
|
test("should handle invalid inputs", () => {
|
|
expect(formatCentsToCurrency("invalid")).toBe("");
|
|
expect(formatCentsToCurrency(Number.NaN)).toBe("");
|
|
});
|
|
});
|
|
|
|
describe("formatCookiesForHeader", () => {
|
|
const mockCookies = [
|
|
{ name: "c_user", value: "123456", domain: ".facebook.com", path: "/" },
|
|
{ name: "xs", value: "abcdef", domain: ".facebook.com", path: "/" },
|
|
{ name: "session_id", value: "xyz", domain: "other.com", path: "/" },
|
|
];
|
|
|
|
test("should format cookies for header string", () => {
|
|
const result = formatCookiesForHeader(mockCookies, "www.facebook.com");
|
|
expect(result).toBe("c_user=123456; xs=abcdef");
|
|
});
|
|
|
|
test("should filter expired cookies", () => {
|
|
const cookiesWithExpiration = [
|
|
...mockCookies,
|
|
{
|
|
name: "expired",
|
|
value: "old",
|
|
domain: ".facebook.com",
|
|
path: "/",
|
|
expirationDate: Date.now() / 1000 - 1000,
|
|
},
|
|
];
|
|
const result = formatCookiesForHeader(
|
|
cookiesWithExpiration,
|
|
"www.facebook.com",
|
|
);
|
|
expect(result).not.toContain("expired");
|
|
});
|
|
|
|
test("should handle no matching cookies", () => {
|
|
const result = formatCookiesForHeader(mockCookies, "www.google.com");
|
|
expect(result).toBe("");
|
|
});
|
|
|
|
test("should handle empty cookie array", () => {
|
|
const result = formatCookiesForHeader([], "www.facebook.com");
|
|
expect(result).toBe("");
|
|
});
|
|
});
|
|
});
|
|
});
|