748 lines
20 KiB
TypeScript
748 lines
20 KiB
TypeScript
import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
|
|
import {
|
|
fetchFacebookItem,
|
|
extractFacebookItemData,
|
|
extractFacebookMarketplaceData,
|
|
parseFacebookItem,
|
|
parseFacebookAds,
|
|
formatCentsToCurrency,
|
|
loadFacebookCookies,
|
|
formatCookiesForHeader,
|
|
parseFacebookCookieString,
|
|
} 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("");
|
|
});
|
|
});
|
|
});
|
|
}); |