@decocms/apps-magento 7.2.0

package/src/__tests__/transform.test.ts

@@ -0,0 +1,346 @@
+/**
+ * Tests for utils/transform.ts — the schema.org mapping layer.
+ *
+ * Parity goals against deco-cx/apps/magento/utils/transform.ts:
+ * each helper is exercised against the same input shapes the legacy
+ * code handled and we assert on the same output shapes the storefront
+ * sections render against. The goal is to keep this file as a
+ * regression dam so future refactors don't silently shift output
+ * structure on real consumer sites.
+ */
+import { describe, expect, it } from "vitest";
+import type { MagentoProduct } from "../utils/client/types";
+import { toBreadcrumbList, toImages, toOffer, toProduct, toSeo, toURL } from "../utils/transform";
+
+const baseProduct = (): MagentoProduct => ({
+	id: 42,
+	sku: "SKU-42",
+	name: "Test Product",
+	price: 100,
+	status: 1,
+	visibility: 4,
+	type_id: "simple",
+	created_at: "",
+	updated_at: "",
+	weight: 0,
+	url: "https://loja.example.com/p/test",
+	extension_attributes: {
+		category_links: [],
+		stock_item: {
+			item_id: 1,
+			product_id: 42,
+			stock_id: 1,
+			is_in_stock: true,
+			qty: 7,
+		},
+	},
+	custom_attributes: [
+		{ attribute_code: "title", value: "Test Title" },
+		{ attribute_code: "meta_title", value: "Test Meta Title" },
+		{ attribute_code: "meta_description", value: "Test Meta Description" },
+	],
+	currency_code: "BRL",
+	price_info: {
+		final_price: 80,
+		max_price: 100,
+		max_regular_price: 100,
+		minimal_regular_price: 100,
+		special_price: null,
+		minimal_price: 80,
+		regular_price: 100,
+		formatted_prices: {
+			final_price: "R$ 80,00",
+			max_price: "R$ 100,00",
+			minimal_price: "R$ 80,00",
+			max_regular_price: "R$ 100,00",
+			minimal_regular_price: null,
+			special_price: null,
+			regular_price: "R$ 100,00",
+		},
+		extension_attributes: {
+			msrp: {
+				msrp_price: "",
+				is_applicable: "",
+				is_shown_price_on_gesture: "",
+				msrp_message: "",
+				explanation_message: "",
+			},
+			tax_adjustments: {
+				final_price: 80,
+				max_price: 100,
+				max_regular_price: 100,
+				minimal_regular_price: 100,
+				special_price: 80,
+				minimal_price: 80,
+				regular_price: 100,
+				formatted_prices: {
+					final_price: "R$ 80,00",
+					max_price: "R$ 100,00",
+					minimal_price: "R$ 80,00",
+					max_regular_price: "R$ 100,00",
+					minimal_regular_price: null,
+					special_price: "R$ 80,00",
+					regular_price: "R$ 100,00",
+				},
+			},
+			weee_attributes: [],
+			weee_adjustment: "",
+		},
+	},
+});
+
+describe("toURL", () => {
+	it("promotes protocol-relative URLs to https", () => {
+		expect(toURL("//cdn.example.com/img.jpg")).toBe("https://cdn.example.com/img.jpg");
+	});
+
+	it("leaves https URLs untouched", () => {
+		expect(toURL("https://x.com/i.jpg")).toBe("https://x.com/i.jpg");
+	});
+
+	it("leaves http URLs untouched (no upgrade)", () => {
+		// Prod only promotes the // form; http:// is passed through to match.
+		expect(toURL("http://x.com/i.jpg")).toBe("http://x.com/i.jpg");
+	});
+});
+
+describe("toSeo", () => {
+	it("prefers meta_title over title", () => {
+		const seo = toSeo(
+			[
+				{ attribute_code: "title", value: "A" },
+				{ attribute_code: "meta_title", value: "B" },
+				{ attribute_code: "meta_description", value: "D" },
+			],
+			"https://x.test/p",
+		);
+		expect(seo).toEqual({ title: "B", description: "D", canonical: "https://x.test/p" });
+	});
+
+	it("falls back to title when meta_title is absent", () => {
+		const seo = toSeo([{ attribute_code: "title", value: "A" }], "https://x.test/p");
+		expect(seo.title).toBe("A");
+	});
+
+	it("returns empty title/description when neither attr is present", () => {
+		const seo = toSeo([], "https://x.test/p");
+		expect(seo).toEqual({ title: "", description: "", canonical: "https://x.test/p" });
+	});
+
+	it("joins string-array attribute values with comma+space", () => {
+		const seo = toSeo(
+			[{ attribute_code: "meta_description", value: ["a", "b", "c"] }],
+			"https://x.test/p",
+		);
+		expect(seo.description).toBe("a, b, c");
+	});
+});
+
+describe("toOffer", () => {
+	it("returns [] when price_info is absent", () => {
+		const p = baseProduct();
+		p.price_info = undefined;
+		expect(toOffer(p, 30, 10)).toEqual([]);
+	});
+
+	it("maps InStock availability when stock_item.is_in_stock=true", () => {
+		const offers = toOffer(baseProduct(), 30, 10);
+		expect(offers[0].availability).toBe("https://schema.org/InStock");
+		expect(offers[0].inventoryLevel).toEqual({ value: 7 });
+	});
+
+	it("maps OutOfStock availability when stock_item.is_in_stock=false", () => {
+		const p = baseProduct();
+		p.extension_attributes.stock_item!.is_in_stock = false;
+		const offers = toOffer(p, 30, 10);
+		expect(offers[0].availability).toBe("https://schema.org/OutOfStock");
+		expect(offers[0].inventoryLevel).toEqual({ value: 0 });
+	});
+
+	it("emits ListPrice + SalePrice in priceSpecification", () => {
+		const offers = toOffer(baseProduct(), 30, 10);
+		const types = (offers[0].priceSpecification ?? []).map((s: any) => s.priceType);
+		expect(types).toContain("https://schema.org/ListPrice");
+		expect(types).toContain("https://schema.org/SalePrice");
+	});
+
+	it("calculates installments capped by maxInstallments AND minInstallmentValue", () => {
+		// finalPrice 80, minInstallmentValue 30 → floor(80/30) = 2 possible
+		// maxInstallments 10 → bounded by 2
+		const offers = toOffer(baseProduct(), 30, 10);
+		const installments = (offers[0].priceSpecification ?? []).filter(
+			(s: any) => s.priceComponentType === "https://schema.org/Installment",
+		);
+		expect(installments.length).toBe(2);
+		expect((installments[0] as any).description).toBe("À vista");
+		expect((installments[1] as any).description).toBe("2x sem juros");
+	});
+
+	it("always emits at least 1 installment (À vista) when finalPrice < minInstallmentValue", () => {
+		// finalPrice 80, minInstallmentValue 200 → floor = 0 → || 1
+		const offers = toOffer(baseProduct(), 200, 10);
+		const installments = (offers[0].priceSpecification ?? []).filter(
+			(s: any) => s.priceComponentType === "https://schema.org/Installment",
+		);
+		expect(installments.length).toBe(1);
+		expect((installments[0] as any).description).toBe("À vista");
+	});
+});
+
+describe("toImages", () => {
+	it("maps media_gallery_entries when imagesUrl is provided", () => {
+		const p = baseProduct();
+		p.media_gallery_entries = [
+			{
+				id: 1,
+				media_type: "image",
+				label: null,
+				position: 1,
+				disabled: false,
+				types: [],
+				file: "/x/y.jpg",
+			},
+		];
+		const imgs = toImages(p, "https://cdn.example/media");
+		expect(imgs).toEqual([
+			{
+				"@type": "ImageObject",
+				encodingFormat: "image",
+				alternateName: "/x/y.jpg",
+				url: "https://cdn.example/media/x/y.jpg",
+				disabled: false,
+			},
+		]);
+	});
+
+	it("falls back to `images` when imagesUrl is empty", () => {
+		const p = baseProduct();
+		p.images = [
+			{
+				url: "https://x.test/i.jpg",
+				code: "image",
+				height: 1,
+				width: 1,
+				label: "x",
+				resized_width: 1,
+				resized_height: 1,
+				disabled: false,
+			},
+		];
+		const imgs = toImages(p, "");
+		expect(imgs?.[0]).toMatchObject({ url: "https://x.test/i.jpg", alternateName: "x" });
+	});
+
+	it("promotes // URLs to https via toURL inside the prefix", () => {
+		const p = baseProduct();
+		p.media_gallery_entries = [
+			{
+				id: 1,
+				media_type: "image",
+				label: null,
+				position: 1,
+				disabled: false,
+				types: [],
+				file: "/x.jpg",
+			},
+		];
+		const imgs = toImages(p, "//cdn.example/m");
+		expect(imgs?.[0].url).toBe("https://cdn.example/m/x.jpg");
+	});
+});
+
+describe("toBreadcrumbList", () => {
+	const PRODUCT_URL = new URL("https://x.test/produto/abc");
+
+	it("returns a single ListItem with the product name when categories=[] and flag=true", () => {
+		const out = toBreadcrumbList(
+			[],
+			true,
+			{ "@type": "Product", productID: "1", sku: "1", name: "Foo" } as any,
+			PRODUCT_URL,
+		);
+		expect(out).toEqual([
+			{
+				"@type": "ListItem",
+				name: "Foo",
+				position: 1,
+				item: "https://x.test/Foo",
+			},
+		]);
+	});
+
+	it("maps each valid category to a ListItem ordered by position", () => {
+		const out = toBreadcrumbList(
+			[{ id: 1, name: "A", position: 1 } as any, { id: 2, name: "B", position: 2 } as any],
+			false,
+			{ name: "Foo" } as any,
+			PRODUCT_URL,
+		);
+		expect(out).toEqual([
+			{ "@type": "ListItem", name: "A", position: 1, item: "https://x.test/A" },
+			{ "@type": "ListItem", name: "B", position: 2, item: "https://x.test/B" },
+		]);
+	});
+
+	it("filters out null/empty-name/zero-position categories", () => {
+		const out = toBreadcrumbList(
+			[
+				null,
+				{ id: 1, name: "", position: 1 } as any,
+				{ id: 2, name: "B", position: 0 } as any,
+				{ id: 3, name: "C", position: 3 } as any,
+			],
+			false,
+			{ name: "Foo" } as any,
+			PRODUCT_URL,
+		);
+		expect(out).toEqual([
+			{ "@type": "ListItem", name: "C", position: 3, item: "https://x.test/C" },
+		]);
+	});
+});
+
+describe("toProduct", () => {
+	it("maps a base product into a schema.org Product with offers, image, additionalProperty", () => {
+		const out = toProduct({
+			product: baseProduct(),
+			options: {
+				currencyCode: "BRL",
+				imagesUrl: "",
+				maxInstallments: 10,
+				minInstallmentValue: 30,
+			},
+		});
+
+		expect(out["@type"]).toBe("Product");
+		expect(out.productID).toBe("42");
+		expect(out.sku).toBe("SKU-42");
+		expect(out.name).toBe("Test Product");
+		expect(out.url).toBe("https://loja.example.com/p/test");
+		expect((out.offers as any).highPrice).toBe(100);
+		expect((out.offers as any).lowPrice).toBe(80);
+		expect(out.additionalProperty?.length).toBe(3);
+	});
+
+	it("wraps the product in isVariantOf with the same productID", () => {
+		const out = toProduct({
+			product: baseProduct(),
+			options: { maxInstallments: 10, minInstallmentValue: 30 },
+		});
+		expect(out.isVariantOf?.productGroupID).toBe("42");
+		expect(out.isVariantOf?.hasVariant?.[0].productID).toBe("42");
+	});
+
+	it("falls back to product.price when price_info is absent for highPrice/lowPrice", () => {
+		const p = baseProduct();
+		p.price_info = undefined;
+		const out = toProduct({
+			product: p,
+			options: { maxInstallments: 10, minInstallmentValue: 30 },
+		});
+		expect((out.offers as any).highPrice).toBe(100);
+		expect((out.offers as any).lowPrice).toBe(100);
+		// And offers array is empty when price_info is absent (toOffer returns [])
+		expect((out.offers as any).offerCount).toBe(0);
+	});
+});

package/src/__tests__/user-loader.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Tests for the user loader.
+ *
+ * Parity goals against deco-cx/apps/magento/loaders/user.ts:
+ *   - Returns null when no PHPSESSID cookie is present (anonymous).
+ *   - Calls /customer/section/load?sections=customer,carbono-customer
+ *     with the Cookie header set from PHPSESSID.
+ *   - Maps the bundle into schema.org Person { @id, email, givenName,
+ *     familyName? }.
+ *   - Derives familyName by stripping firstname from fullname (matches
+ *     prod's `fullname.replace(firstname, "").trim()`).
+ *   - Returns null when carbono-customer.data_id is missing OR when
+ *     customer slice is absent.
+ *   - Swallows fetch errors and returns null (the storefront re-renders
+ *     the logged-out UI rather than crashing).
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { configureMagento } from "../client";
+import user from "../loaders/user";
+
+function mockResponse(body: unknown, status = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" },
+	});
+}
+
+function requestWithCookie(cookie: string): Request {
+	const r = new Request("http://localhost/");
+	const headers = new Headers();
+	headers.set("cookie", cookie);
+	Object.defineProperty(r, "headers", { value: headers, configurable: true });
+	return r;
+}
+
+describe("user loader", () => {
+	let fetchSpy: ReturnType<typeof vi.spyOn>;
+
+	beforeEach(() => {
+		configureMagento({
+			baseUrl: "https://loja.example.com/",
+			apiKey: "secret",
+			storeId: 1,
+			site: "example",
+		});
+		fetchSpy = vi.spyOn(globalThis, "fetch");
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("returns null when no PHPSESSID cookie is present", async () => {
+		const result = await user(null, new Request("http://localhost/"));
+		expect(result).toBeNull();
+		expect(fetchSpy).not.toHaveBeenCalled();
+	});
+
+	it("requests /customer/section/load with the Cookie header", async () => {
+		fetchSpy.mockResolvedValue(
+			mockResponse({
+				customer: { data_id: 1, fullname: "Alice Doe", firstname: "Alice" },
+				"carbono-customer": { data_id: 1, customerId: "c1", email: "a@b.com" },
+			}),
+		);
+		await user(null, requestWithCookie("PHPSESSID=abc"));
+		const [target, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
+		expect(target.toString()).toBe(
+			"https://loja.example.com/example/customer/section/load?sections=customer,carbono-customer",
+		);
+		const cookieHeader = new Headers(init.headers).get("cookie");
+		expect(cookieHeader).toBe("PHPSESSID=abc");
+	});
+
+	it("maps a happy-path bundle into a schema.org Person", async () => {
+		fetchSpy.mockResolvedValue(
+			mockResponse({
+				customer: { data_id: 1, fullname: "Alice Doe", firstname: "Alice" },
+				"carbono-customer": { data_id: 1, customerId: "c1", email: "a@b.com" },
+			}),
+		);
+		const out = await user(null, requestWithCookie("PHPSESSID=abc"));
+		expect(out).toEqual({
+			"@id": "c1",
+			email: "a@b.com",
+			givenName: "Alice",
+			familyName: "Doe",
+		});
+	});
+
+	it("omits familyName when fullname is just firstname (no surname)", async () => {
+		fetchSpy.mockResolvedValue(
+			mockResponse({
+				customer: { data_id: 1, fullname: "Alice", firstname: "Alice" },
+				"carbono-customer": { data_id: 1, customerId: "c1", email: "a@b.com" },
+			}),
+		);
+		const out = await user(null, requestWithCookie("PHPSESSID=abc"));
+		expect(out).toMatchObject({ givenName: "Alice" });
+		// Magento returns fullname=firstname; prod's `replace(firstname, "").trim()`
+		// yields "" — we include the key with an empty string. Test the
+		// surface, not the empty-vs-missing detail.
+		expect(out?.familyName ?? "").toBe("");
+	});
+
+	it("returns null when carbono-customer.data_id is missing", async () => {
+		fetchSpy.mockResolvedValue(
+			mockResponse({
+				customer: { data_id: 1, fullname: "Alice Doe", firstname: "Alice" },
+				"carbono-customer": { customerId: "c1", email: "a@b.com" }, // no data_id
+			}),
+		);
+		expect(await user(null, requestWithCookie("PHPSESSID=abc"))).toBeNull();
+	});
+
+	it("returns null when customer slice is absent", async () => {
+		fetchSpy.mockResolvedValue(
+			mockResponse({
+				"carbono-customer": { data_id: 1, customerId: "c1", email: "a@b.com" },
+			}),
+		);
+		expect(await user(null, requestWithCookie("PHPSESSID=abc"))).toBeNull();
+	});
+
+	it("returns null when fetch throws", async () => {
+		fetchSpy.mockRejectedValue(new Error("ECONNREFUSED"));
+		expect(await user(null, requestWithCookie("PHPSESSID=abc"))).toBeNull();
+	});
+
+	it("returns null on non-2xx response", async () => {
+		fetchSpy.mockResolvedValue(mockResponse(null, 500));
+		expect(await user(null, requestWithCookie("PHPSESSID=abc"))).toBeNull();
+	});
+});

package/src/__tests__/wishlist-actions.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Tests for the wishlist add/remove actions.
+ *
+ * Parity goals against deco-cx/apps/magento/actions/wishlist/{addItem,removeItem}:
+ *   - Both require PHPSESSID + form_key cookies; return null when either absent.
+ *   - addItem POSTs FormData {product, form_key} to /wishlist/index/add/.
+ *   - removeItem POSTs FormData {item, uenc:"", form_key} to /wishlist/index/remove/.
+ *   - On success ({success:true}) both delegate to the wishlist loader to
+ *     fetch the refreshed list.
+ *   - Failure / thrown / success:false → null.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import addItem from "../actions/wishlist/addItem";
+import removeItem from "../actions/wishlist/removeItem";
+import { configureMagento } from "../client";
+
+function mockResponse(body: unknown, status = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" },
+	});
+}
+
+function requestWithCookies(cookieHeader: string): Request {
+	const r = new Request("http://localhost/");
+	const headers = new Headers();
+	headers.set("cookie", cookieHeader);
+	Object.defineProperty(r, "headers", { value: headers, configurable: true });
+	return r;
+}
+
+const AUTHED = "PHPSESSID=abc; form_key=xyz";
+
+describe("wishlist/addItem", () => {
+	let fetchSpy: ReturnType<typeof vi.spyOn>;
+
+	beforeEach(() => {
+		configureMagento({
+			baseUrl: "https://loja.example.com/",
+			apiKey: "secret",
+			storeId: 1,
+			site: "example",
+		});
+		fetchSpy = vi.spyOn(globalThis, "fetch");
+	});
+
+	afterEach(() => vi.restoreAllMocks());
+
+	it("returns null when PHPSESSID is missing", async () => {
+		expect(await addItem({ productId: "1" }, requestWithCookies("form_key=xyz"))).toBeNull();
+	});
+
+	it("returns null when form_key is missing", async () => {
+		expect(await addItem({ productId: "1" }, requestWithCookies("PHPSESSID=abc"))).toBeNull();
+	});
+
+	it("POSTs FormData {product, form_key} to /wishlist/index/add/", async () => {
+		fetchSpy
+			.mockResolvedValueOnce(mockResponse({ success: true })) // POST add
+			.mockResolvedValueOnce(
+				mockResponse({
+					wishlist: { counter: "1", items: [], counter_number: 1, data_id: 1 },
+				}),
+			); // wishlist loader fetch
+
+		await addItem({ productId: "p42" }, requestWithCookies(AUTHED));
+
+		const [target, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
+		expect(target.toString()).toBe("https://loja.example.com/example/wishlist/index/add/");
+		expect(init.method).toBe("POST");
+
+		const fd = init.body as FormData;
+		expect(fd.get("product")).toBe("p42");
+		expect(fd.get("form_key")).toBe("xyz");
+	});
+
+	it("delegates to the wishlist loader on success", async () => {
+		const wl = { counter: "1", items: [], counter_number: 1, data_id: 1 };
+		fetchSpy
+			.mockResolvedValueOnce(mockResponse({ success: true }))
+			.mockResolvedValueOnce(mockResponse({ wishlist: wl }));
+
+		expect(await addItem({ productId: "p42" }, requestWithCookies(AUTHED))).toEqual(wl);
+	});
+
+	it("returns null when Magento responds with success:false", async () => {
+		fetchSpy.mockResolvedValueOnce(mockResponse({ success: false }));
+		expect(await addItem({ productId: "p42" }, requestWithCookies(AUTHED))).toBeNull();
+	});
+
+	it("returns null on a thrown fetch", async () => {
+		fetchSpy.mockRejectedValueOnce(new Error("boom"));
+		expect(await addItem({ productId: "p42" }, requestWithCookies(AUTHED))).toBeNull();
+	});
+});
+
+describe("wishlist/removeItem", () => {
+	let fetchSpy: ReturnType<typeof vi.spyOn>;
+
+	beforeEach(() => {
+		configureMagento({
+			baseUrl: "https://loja.example.com/",
+			apiKey: "secret",
+			storeId: 1,
+			site: "example",
+		});
+		fetchSpy = vi.spyOn(globalThis, "fetch");
+	});
+
+	afterEach(() => vi.restoreAllMocks());
+
+	it("POSTs FormData {item, uenc:'', form_key} to /wishlist/index/remove/", async () => {
+		fetchSpy.mockResolvedValueOnce(mockResponse({ success: true })).mockResolvedValueOnce(
+			mockResponse({
+				wishlist: { counter: "0", items: [], counter_number: 0, data_id: 1 },
+			}),
+		);
+
+		await removeItem({ productId: "row-42" }, requestWithCookies(AUTHED));
+
+		const [target, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
+		expect(target.toString()).toBe("https://loja.example.com/example/wishlist/index/remove/");
+		const fd = init.body as FormData;
+		expect(fd.get("item")).toBe("row-42");
+		expect(fd.get("uenc")).toBe("");
+		expect(fd.get("form_key")).toBe("xyz");
+	});
+
+	it("returns the refreshed wishlist on success", async () => {
+		const wl = { counter: "0", items: [], counter_number: 0, data_id: 1 };
+		fetchSpy
+			.mockResolvedValueOnce(mockResponse({ success: true }))
+			.mockResolvedValueOnce(mockResponse({ wishlist: wl }));
+		expect(await removeItem({ productId: "row-42" }, requestWithCookies(AUTHED))).toEqual(wl);
+	});
+
+	it("returns null when PHPSESSID is missing", async () => {
+		expect(await removeItem({ productId: "x" }, requestWithCookies("form_key=xyz"))).toBeNull();
+	});
+});