@decocms/apps-magento 8.1.0-next.0 → 8.1.0-next.2

package/src/__tests__/client.test.ts

@@ -1,252 +0,0 @@
-/**
- * Tests for the Magento client config + magentoFetch wrapper.
- *
- * Parity goals — behavior these tests pin down so the port stays aligned
- * with deco-cx/apps/magento (Fresh/Deno, prod):
- *
- *  - configureMagento / getMagentoConfig is a write-once-read-many global
- *    (mirrors configureVtex). getMagentoConfig() throws before configure().
- *  - magentoFetch:
- *      • Same-origin: attaches Authorization (Bearer apiKey),
- *        x-origin-header (when configured), and a forced Referer pointing
- *        at baseUrl — exactly the headers the Fresh `clientAdmin` was
- *        built with at App() time.
- *      • Cross-origin: strips ALL Magento-only identity headers so the
- *        admin Bearer + origin secret never leak to a third party. Caller
- *        headers pass through.
- *      • authenticated:false opt-out drops Bearer even on same-origin.
- *      • Relative paths resolve against baseUrl with proper "/" handling.
- *      • Absolute https://… paths bypass baseUrl entirely.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { configureMagento, getMagentoConfig, magentoFetch } from "../client";
-
-// Reset module-global config between tests by re-importing.
-beforeEach(() => {
-	vi.resetModules();
-});
-
-afterEach(() => {
-	vi.restoreAllMocks();
-});
-
-describe("configureMagento / getMagentoConfig", () => {
-	it("throws before configureMagento() is called", async () => {
-		const { getMagentoConfig: freshGet } = await import("../client");
-		expect(() => freshGet()).toThrow(/configureMagento\(\) must be called/);
-	});
-
-	it("returns the configured value after configureMagento()", async () => {
-		const { configureMagento: c, getMagentoConfig: g } = await import("../client");
-		c({
-			baseUrl: "https://loja.example.com/",
-			apiKey: "test-key",
-			storeId: 1,
-			site: "example",
-		});
-		expect(g().baseUrl).toBe("https://loja.example.com/");
-		expect(g().apiKey).toBe("test-key");
-	});
-});
-
-describe("magentoFetch — same-origin (configured baseUrl)", () => {
-	const baseUrl = "https://loja.example.com/";
-	let fetchSpy: ReturnType<typeof vi.spyOn>;
-
-	beforeEach(() => {
-		configureMagento({
-			baseUrl,
-			apiKey: "secret-bearer",
-			storeId: 1,
-			site: "example",
-			originHeader: "origin-secret",
-		});
-		fetchSpy = vi
-			.spyOn(globalThis, "fetch")
-			.mockResolvedValue(
-				new Response("{}", { status: 200, headers: { "content-type": "application/json" } }),
-			);
-	});
-
-	it("attaches Authorization, x-origin-header, and forced Referer", async () => {
-		await magentoFetch("/rest/example/V1/carts/123");
-		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		const headers = init.headers as Headers;
-		expect(headers.get("authorization")).toBe("Bearer secret-bearer");
-		expect(headers.get("x-origin-header")).toBe("origin-secret");
-		expect(headers.get("referer")).toBe(baseUrl);
-	});
-
-	it("resolves relative path against baseUrl with correct slash handling", async () => {
-		await magentoFetch("rest/example/V1/carts/123"); // no leading slash
-		const [target] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		expect(target.toString()).toBe("https://loja.example.com/rest/example/V1/carts/123");
-	});
-
-	it("authenticated:false suppresses Bearer even on same-origin", async () => {
-		await magentoFetch("/rest/example/V1/carts/123", { authenticated: false });
-		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		const headers = init.headers as Headers;
-		expect(headers.get("authorization")).toBeNull();
-		// Same-origin still gets the other Magento-identity headers.
-		expect(headers.get("x-origin-header")).toBe("origin-secret");
-	});
-
-	it("preserves caller-supplied Referer (no force-overwrite when caller set one)", async () => {
-		await magentoFetch("/rest/example/V1/carts/123", {
-			headers: { Referer: "https://caller.example/page" },
-		});
-		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		const headers = init.headers as Headers;
-		expect(headers.get("referer")).toBe("https://caller.example/page");
-	});
-});
-
-describe("magentoFetch — cross-origin guard", () => {
-	let fetchSpy: ReturnType<typeof vi.spyOn>;
-
-	beforeEach(() => {
-		configureMagento({
-			baseUrl: "https://loja.example.com/",
-			apiKey: "secret-bearer",
-			storeId: 1,
-			site: "example",
-			originHeader: "origin-secret",
-		});
-		fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response("{}", { status: 200 }));
-	});
-
-	it("strips Bearer when fetching a non-Magento host", async () => {
-		await magentoFetch("https://attacker.example/api");
-		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		const headers = init.headers as Headers;
-		expect(headers.get("authorization")).toBeNull();
-	});
-
-	it("strips x-origin-header when fetching a non-Magento host", async () => {
-		// Regression for cubic review: the previous fix only dropped Bearer
-		// while x-origin-header and Referer still leaked.
-		await magentoFetch("https://attacker.example/api");
-		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		const headers = init.headers as Headers;
-		expect(headers.get("x-origin-header")).toBeNull();
-	});
-
-	it("strips forced Referer when fetching a non-Magento host", async () => {
-		await magentoFetch("https://attacker.example/api");
-		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		const headers = init.headers as Headers;
-		// Referer to https://loja.example.com/ would broadcast the Magento
-		// host to the third party — must not be set by us.
-		expect(headers.get("referer")).toBeNull();
-	});
-
-	it("still forwards caller-supplied headers cross-origin", async () => {
-		await magentoFetch("https://partner.example/api", {
-			headers: { "x-correlation-id": "abc123" },
-		});
-		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		const headers = init.headers as Headers;
-		expect(headers.get("x-correlation-id")).toBe("abc123");
-	});
-
-	it("treats an absolute URL with the same origin as same-origin", async () => {
-		await magentoFetch("https://loja.example.com/rest/example/V1/carts/123");
-		const [target, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
-		expect(target.toString()).toBe("https://loja.example.com/rest/example/V1/carts/123");
-		expect((init.headers as Headers).get("authorization")).toBe("Bearer secret-bearer");
-	});
-});
-
-describe("initMagentoFromBlocks — secret resolution", () => {
-	beforeEach(() => {
-		vi.resetModules();
-	});
-
-	it("returns early when the `magento` block is absent", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const { initMagentoFromBlocks, getMagentoConfig } = await import("../client");
-		await initMagentoFromBlocks({});
-		expect(warn).toHaveBeenCalledWith(expect.stringContaining("No `magento` block"));
-		expect(() => getMagentoConfig()).toThrow(/configureMagento\(\) must be called/);
-	});
-
-	it("reads plain-string apiKey directly", async () => {
-		const { initMagentoFromBlocks, getMagentoConfig } = await import("../client");
-		await initMagentoFromBlocks({
-			magento: {
-				apiConfig: {
-					baseUrl: "https://loja.example.com/",
-					apiKey: "plain-string-key",
-					site: "example",
-					storeId: 1,
-				},
-			},
-		});
-		expect(getMagentoConfig().apiKey).toBe("plain-string-key");
-	});
-
-	it("dereferences a Secret-shaped apiKey via process.env (the env fallback path)", async () => {
-		process.env.TEST_MAGENTO_KEY = "from-env";
-		const { initMagentoFromBlocks, getMagentoConfig } = await import("../client");
-		await initMagentoFromBlocks({
-			magento: {
-				apiConfig: {
-					baseUrl: "https://loja.example.com/",
-					apiKey: {
-						__resolveType: "website/loaders/secret.ts",
-						name: "TEST_MAGENTO_KEY",
-					},
-					site: "example",
-					storeId: 1,
-				},
-			},
-		});
-		expect(getMagentoConfig().apiKey).toBe("from-env");
-		delete process.env.TEST_MAGENTO_KEY;
-	});
-
-	it("falls back to empty string when secret is unresolvable", async () => {
-		// no DECO_CRYPTO_KEY, no env var with this name, no decrypt
-		// → resolveSecret returns null → init writes "".
-		delete process.env.DECO_CRYPTO_KEY;
-		const { initMagentoFromBlocks, getMagentoConfig } = await import("../client");
-		await initMagentoFromBlocks({
-			magento: {
-				apiConfig: {
-					baseUrl: "https://loja.example.com/",
-					apiKey: {
-						__resolveType: "website/loaders/secret.ts",
-						encrypted: "deadbeef",
-						name: "UNDEFINED_ENV_VAR_DO_NOT_SET",
-					},
-					site: "example",
-					storeId: 1,
-				},
-			},
-		});
-		expect(getMagentoConfig().apiKey).toBe("");
-	});
-
-	it("resolves both apiKey and originHeader independently", async () => {
-		process.env.TEST_API_KEY = "api-from-env";
-		process.env.TEST_ORIGIN = "origin-from-env";
-		const { initMagentoFromBlocks, getMagentoConfig } = await import("../client");
-		await initMagentoFromBlocks({
-			magento: {
-				apiConfig: {
-					baseUrl: "https://loja.example.com/",
-					apiKey: { name: "TEST_API_KEY" },
-					originHeader: { name: "TEST_ORIGIN" },
-					site: "example",
-					storeId: 1,
-				},
-			},
-		});
-		const cfg = getMagentoConfig();
-		expect(cfg.apiKey).toBe("api-from-env");
-		expect(cfg.originHeader).toBe("origin-from-env");
-		delete process.env.TEST_API_KEY;
-		delete process.env.TEST_ORIGIN;
-	});
-});

package/src/__tests__/features.test.ts

@@ -1,51 +0,0 @@
-/**
- * Tests for the features loader.
- *
- * Parity with deco-cx/apps/magento/loaders/features.ts (Fresh/Deno, prod):
- * the legacy loader was a 3-arg `(_props, _req, ctx) => ctx.features`.
- * The ported version uses the module-global config instead of a per-
- * request ctx, but the surface area downstream is the same — a plain
- * object pulled from the resolved magento CMS block.
- */
-import { beforeEach, describe, expect, it } from "vitest";
-import { configureMagento } from "../client";
-import features from "../loaders/features";
-
-describe("features loader", () => {
-	beforeEach(() => {
-		configureMagento({
-			baseUrl: "https://loja.example.com/",
-			apiKey: "key",
-			storeId: 1,
-			site: "example",
-			features: {
-				dangerouslyDisableWishlist: false,
-				dangerouslyDisableOnLoadUpdate: true,
-				dangerouslyReturnNullAfterAction: true,
-				dangerouslyDontReturnCartAfterAction: true,
-				dangerouslyDisableOnVisibilityChangeUpdate: true,
-			},
-		});
-	});
-
-	it("returns the feature flags object from the config", () => {
-		expect(features()).toEqual({
-			dangerouslyDisableWishlist: false,
-			dangerouslyDisableOnLoadUpdate: true,
-			dangerouslyReturnNullAfterAction: true,
-			dangerouslyDontReturnCartAfterAction: true,
-			dangerouslyDisableOnVisibilityChangeUpdate: true,
-		});
-	});
-
-	it("returns an empty object when features are not configured", () => {
-		configureMagento({
-			baseUrl: "https://loja.example.com/",
-			apiKey: "key",
-			storeId: 1,
-			site: "example",
-			// features omitted
-		});
-		expect(features()).toEqual({});
-	});
-});

package/src/__tests__/graphql.test.ts

@@ -1,183 +0,0 @@
-/**
- * Tests for the GraphQL helpers used by product loaders.
- *
- * Parity with deco-cx/apps/magento/utils/graphql.ts — pure functions,
- * so behavior is exhaustively pinnable. Each test mirrors a real call
- * site in the (still-unported) product loaders.
- */
-import { describe, expect, it } from "vitest";
-import {
-	filtersFromLoaderGraphQL,
-	filtersFromUrlGraphQL,
-	formatUrlSuffix,
-	getCustomFields,
-	transformFilterGraphQL,
-	transformFilterValueGraphQL,
-	transformSortGraphQL,
-} from "../utils/graphql";
-
-describe("transformSortGraphQL", () => {
-	it("returns undefined when sortBy is absent", () => {
-		expect(transformSortGraphQL({})).toBeUndefined();
-		expect(transformSortGraphQL({ order: "DESC" })).toBeUndefined();
-	});
-
-	it("defaults order to ASC when not provided", () => {
-		expect(transformSortGraphQL({ sortBy: { value: "price" } })).toEqual({
-			price: "ASC",
-		});
-	});
-
-	it("respects DESC order", () => {
-		expect(transformSortGraphQL({ sortBy: { value: "name" }, order: "DESC" })).toEqual({
-			name: "DESC",
-		});
-	});
-
-	it("supports custom sort options (any string value)", () => {
-		expect(transformSortGraphQL({ sortBy: { value: "best_seller_rank" } as any })).toEqual({
-			best_seller_rank: "ASC",
-		});
-	});
-});
-
-describe("transformFilterValueGraphQL", () => {
-	it("EQUAL → { eq: value }", () => {
-		expect(transformFilterValueGraphQL("ABC", "EQUAL")).toEqual({ eq: "ABC" });
-	});
-
-	it("MATCH → { match: value }", () => {
-		expect(transformFilterValueGraphQL("foo bar", "MATCH")).toEqual({
-			match: "foo bar",
-		});
-	});
-
-	it("RANGE → { from, to } split on the FIRST underscore", () => {
-		expect(transformFilterValueGraphQL("10_50", "RANGE")).toEqual({
-			from: "10",
-			to: "50",
-		});
-	});
-
-	it("RANGE with multi-underscore value: only first underscore splits", () => {
-		// Magento's URL param `price=10_50_extra` is unusual but pinned
-		// to substring(0, idx) + substring(idx+1) which keeps the trailing
-		// underscore on the `to` side.
-		expect(transformFilterValueGraphQL("10_50_extra", "RANGE")).toEqual({
-			from: "10",
-			to: "50_extra",
-		});
-	});
-});
-
-describe("filtersFromUrlGraphQL", () => {
-	it("picks up known filter keys from URL searchParams", () => {
-		const url = new URL("https://x.test/?sku=ABC&color=red&unknown=zzz");
-		expect(filtersFromUrlGraphQL(url)).toEqual({
-			sku: { eq: "ABC" },
-			color: { eq: "red" },
-		});
-	});
-
-	it("handles RANGE filters (price)", () => {
-		const url = new URL("https://x.test/?price=10_50");
-		expect(filtersFromUrlGraphQL(url)).toEqual({
-			price: { from: "10", to: "50" },
-		});
-	});
-
-	it("handles MATCH filters (name, description)", () => {
-		const url = new URL("https://x.test/?name=foo+bar");
-		expect(filtersFromUrlGraphQL(url)).toEqual({
-			name: { match: "foo bar" },
-		});
-	});
-
-	it("layers customFilters on top of defaults", () => {
-		const url = new URL("https://x.test/?tag__phebo=fragrancia&sku=X");
-		expect(filtersFromUrlGraphQL(url, [{ value: "tag__phebo", type: "EQUAL" }])).toEqual({
-			tag__phebo: { eq: "fragrancia" },
-			sku: { eq: "X" },
-		});
-	});
-
-	it("returns empty object when no filterable param is set", () => {
-		expect(filtersFromUrlGraphQL(new URL("https://x.test/?totally=other"))).toEqual({});
-	});
-});
-
-describe("filtersFromLoaderGraphQL", () => {
-	it("returns empty object when undefined", () => {
-		expect(filtersFromLoaderGraphQL(undefined)).toEqual({});
-	});
-
-	it("collapses array of FilterProps into a keyed object", () => {
-		expect(
-			filtersFromLoaderGraphQL([
-				{ name: "sku", type: { eq: "A" } },
-				{ name: "color", type: { in: ["red", "blue"] } },
-			]),
-		).toEqual({
-			sku: { eq: "A" },
-			color: { in: ["red", "blue"] },
-		});
-	});
-});
-
-describe("transformFilterGraphQL — merge order", () => {
-	it("loader-derived filters override URL-derived ones on key collisions", () => {
-		// A section hard-coding `sale=true` should ignore any conflicting URL hint.
-		const url = new URL("https://x.test/?sale=false");
-		expect(
-			transformFilterGraphQL(url, undefined, [{ name: "sale", type: { eq: "true" } }]),
-		).toEqual({
-			sale: { eq: "true" },
-		});
-	});
-
-	it("non-colliding sources merge cleanly", () => {
-		const url = new URL("https://x.test/?sku=ABC");
-		expect(
-			transformFilterGraphQL(url, undefined, [{ name: "category_id", type: { eq: "42" } }]),
-		).toEqual({
-			sku: { eq: "ABC" },
-			category_id: { eq: "42" },
-		});
-	});
-});
-
-describe("formatUrlSuffix", () => {
-	it("strips a single leading slash", () => {
-		expect(formatUrlSuffix("/acme/")).toBe("acme/");
-	});
-
-	it("appends trailing slash when missing", () => {
-		expect(formatUrlSuffix("acme")).toBe("acme/");
-	});
-
-	it("leaves trailing slash alone", () => {
-		expect(formatUrlSuffix("acme/")).toBe("acme/");
-	});
-});
-
-describe("getCustomFields", () => {
-	it("returns undefined when active=false", () => {
-		expect(getCustomFields({ active: false }, ["a", "b"])).toBeUndefined();
-	});
-
-	it("returns overrideList when present (ignores fallback)", () => {
-		expect(getCustomFields({ active: true, overrideList: ["x", "y"] }, ["a", "b"])).toEqual([
-			"x",
-			"y",
-		]);
-	});
-
-	it("falls back to provided customFields when overrideList is empty/absent", () => {
-		expect(getCustomFields({ active: true, overrideList: [] }, ["a", "b"])).toEqual(["a", "b"]);
-		expect(getCustomFields({ active: true }, ["a", "b"])).toEqual(["a", "b"]);
-	});
-
-	it("defaults config to {active:false} when omitted", () => {
-		expect(getCustomFields(undefined, ["a"])).toBeUndefined();
-	});
-});

package/src/__tests__/magentoClient.test.ts

@@ -1,166 +0,0 @@
-// @vitest-environment node
-/**
- * The v8 Magento client (/next/upstream-clients): every request goes through
- * the instrumented fetch as provider "magento", named by its operation; the
- * store's credentials only go to the store; errors never carry bodies.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const instrumented = vi.hoisted(() => ({
-  providers: [] as string[],
-  operations: [] as (string | undefined)[],
-}));
-
-vi.mock("@decocms/blocks/fetch", async (importOriginal) => {
-  const real = await importOriginal<typeof import("@decocms/blocks/fetch")>();
-  return {
-    createInstrumentedFetch: (options: Parameters<typeof real.createInstrumentedFetch>[0]) => {
-      instrumented.providers.push(options.provider);
-      const request = real.createInstrumentedFetch(options);
-      return (input: string | URL | Request, init?: RequestInit & { operation?: string }) => {
-        instrumented.operations.push(init?.operation);
-        return request(input, init);
-      };
-    },
-  };
-});
-
-import { createMagentoClient, MagentoError } from "../magentoClient";
-
-/** The error a call rejects with (fails the test if it resolves). */
-const failure = (call: Promise<unknown>): Promise<Error> =>
-  call.then(
-    () => {
-      throw new Error("expected the call to fail");
-    },
-    (error: Error) => error,
-  );
-
-function upstream(body: unknown, status = 200) {
-  return vi.fn(
-    async (_input: string | URL | Request, _init?: RequestInit) =>
-      new Response(JSON.stringify(body), { status }),
-  );
-}
-
-const config = { baseUrl: "https://store.example.com/", apiKey: "key", originHeader: "origin" };
-
-beforeEach(() => {
-  instrumented.providers.length = 0;
-  instrumented.operations.length = 0;
-});
-
-describe("createMagentoClient", () => {
-  it("calls REST with the store credentials, labeled by operation", async () => {
-    const fetch = upstream({ id: 7 });
-    const magento = createMagentoClient(config, { fetch });
-
-    expect(
-      await magento.rest<{ id: number }>("/rest/default/V1/carts/7", { operation: "getCart" }),
-    ).toEqual({ id: 7 });
-    expect(instrumented.providers).toEqual(["magento"]);
-    expect(instrumented.operations).toEqual(["getCart"]);
-    const [url, init] = fetch.mock.calls[0]!;
-    expect(String(url)).toBe("https://store.example.com/rest/default/V1/carts/7");
-    const headers = new Headers(init?.headers);
-    expect(headers.get("authorization")).toBe("Bearer key");
-    expect(headers.get("x-origin-header")).toBe("origin");
-  });
-
-  it("omits the token when a call opts out", async () => {
-    const fetch = upstream({});
-    const magento = createMagentoClient(config, { fetch });
-    await magento.request("/customer/section/load", {
-      operation: "loadSections",
-      authenticated: false,
-    });
-    expect(new Headers(fetch.mock.calls[0]![1]?.headers).get("authorization")).toBeNull();
-  });
-
-  it("refuses URLs on another origin, so the token never leaves the store", async () => {
-    const fetch = upstream({});
-    const magento = createMagentoClient(config, { fetch });
-    await expect(magento.request("https://evil.example/steal", { operation: "x" })).rejects.toThrow(
-      /only paths on the configured store/,
-    );
-    await expect(magento.request("//evil.example/steal", { operation: "x" })).rejects.toThrow(
-      /only paths on the configured store/,
-    );
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it("keeps a customer Authorization header instead of the store's token", async () => {
-    const fetch = upstream({ data: { customer: { email: "a" } }, items: [] });
-    const magento = createMagentoClient(config, { fetch });
-    await magento.graphql("query Customer { customer { email } }", undefined, {
-      operationName: "Customer",
-      headers: { Authorization: "Bearer customer" },
-    });
-    await magento.rest("/rest/default/V1/carts/mine", {
-      operation: "getCart",
-      headers: { Authorization: "Bearer customer" },
-    });
-    for (const [, init] of fetch.mock.calls) {
-      expect(new Headers(init?.headers).get("authorization")).toBe("Bearer customer");
-    }
-  });
-
-  it("sends GraphQL without the store's token unless asked, and keeps the JSON content type", async () => {
-    const fetch = upstream({ data: {} });
-    const magento = createMagentoClient(config, { fetch });
-    await magento.graphql("query Q { a }", undefined, {
-      operationName: "Q",
-      headers: { "Content-Type": "text/plain" },
-    });
-    await magento.graphql("query Q { a }", undefined, { operationName: "Q", authenticated: true });
-    const [first, second] = fetch.mock.calls.map(([, init]) => new Headers(init?.headers));
-    expect(first!.get("authorization")).toBeNull();
-    expect(first!.get("content-type")).toBe("application/json");
-    expect(second!.get("authorization")).toBe("Bearer key");
-  });
-
-  it("returns undefined for a 204 REST response", async () => {
-    const fetch = vi.fn(async () => new Response(null, { status: 204 }));
-    const magento = createMagentoClient(config, { fetch });
-    await expect(
-      magento.rest("/rest/default/V1/carts/mine/items/1", {
-        operation: "removeCartItem",
-        method: "DELETE",
-      }),
-    ).resolves.toBeUndefined();
-  });
-
-  it("sends GraphQL with its operationName, which is the label", async () => {
-    const fetch = upstream({ data: { productStockAlert: { status: true } } });
-    const magento = createMagentoClient(config, { fetch });
-    const data = await magento.graphql<{ productStockAlert: { status: boolean } }>(
-      "mutation ProductStockAlert($sku: String!) { productStockAlert(sku: $sku) { status } }",
-      { sku: "A1" },
-      { operationName: "ProductStockAlert", headers: { Store: "default" } },
-    );
-    expect(data.productStockAlert.status).toBe(true);
-    expect(instrumented.operations).toEqual(["ProductStockAlert"]);
-    const [url, init] = fetch.mock.calls[0]!;
-    expect(String(url)).toBe("https://store.example.com/graphql");
-    expect(new Headers(init?.headers).get("store")).toBe("default");
-    expect(JSON.parse(String(init?.body))).toMatchObject({
-      operationName: "ProductStockAlert",
-      variables: { sku: "A1" },
-    });
-  });
-
-  it("throws a MagentoError without the body", async () => {
-    const magento = createMagentoClient(config, {
-      fetch: upstream({ message: "token key invalid" }, 401),
-    });
-    const error = await failure(magento.rest("/rest/V1/carts/mine", { operation: "getCart" }));
-    expect(error).toBeInstanceOf(MagentoError);
-    expect(error.message).toBe("magento getCart failed with HTTP 401");
-
-    const gql = createMagentoClient(config, {
-      fetch: upstream({ errors: [{ message: "x@example.com" }] }),
-    });
-    const gqlError = await failure(gql.graphql("query Q { a }", undefined, { operationName: "Q" }));
-    expect(gqlError.message).toBe("magento Q returned 1 GraphQL error(s)");
-  });
-});