@decocms/apps-vtex 8.0.0 → 8.1.0-next.1

package/src/utils/__tests__/operationRouter.test.ts

@@ -1,227 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { vtexOperationRouter } from "../operationRouter";
-
-describe("vtexOperationRouter", () => {
-	const acct = "https://store.vtexcommercestable.com.br";
-
-	describe("Intelligent Search", () => {
-		it("captures the IS endpoint as the operation suffix", () => {
-			expect(
-				vtexOperationRouter(
-					`${acct}/api/io/_v/api/intelligent-search/product_search/electronics`,
-					"GET",
-				),
-			).toBe("intelligent-search.product_search");
-			expect(
-				vtexOperationRouter(`${acct}/api/io/_v/api/intelligent-search/top_searches`, "GET"),
-			).toBe("intelligent-search.top_searches");
-			expect(vtexOperationRouter(`${acct}/api/io/_v/api/intelligent-search/facets`, "GET")).toBe(
-				"intelligent-search.facets",
-			);
-			expect(
-				vtexOperationRouter(`${acct}/api/io/_v/api/intelligent-search/search_suggestions`, "GET"),
-			).toBe("intelligent-search.search_suggestions");
-		});
-
-		it("strips query string before matching", () => {
-			expect(
-				vtexOperationRouter(
-					`${acct}/api/io/_v/api/intelligent-search/product_search?query=foo&sort=price`,
-					"GET",
-				),
-			).toBe("intelligent-search.product_search");
-		});
-	});
-
-	describe("Checkout / orderForm", () => {
-		it("differentiates create vs get on orderForm", () => {
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm`, "POST")).toBe(
-				"checkout.orderform.create",
-			);
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm`, "GET")).toBe(
-				"checkout.orderform.get",
-			);
-		});
-
-		it("differentiates items add/update/remove by HTTP method", () => {
-			const url = `${acct}/api/checkout/pub/orderForm/abc123/items`;
-			expect(vtexOperationRouter(url, "POST")).toBe("checkout.orderform.items.add");
-			expect(vtexOperationRouter(url, "PATCH")).toBe("checkout.orderform.items.update");
-			expect(vtexOperationRouter(url, "PUT")).toBe("checkout.orderform.items.update");
-			expect(vtexOperationRouter(url, "DELETE")).toBe("checkout.orderform.items.remove");
-		});
-
-		it("recognizes the /items/update legacy mass-update endpoint", () => {
-			expect(
-				vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/abc123/items/update`, "POST"),
-			).toBe("checkout.orderform.items.update");
-		});
-
-		it("handles coupons, profile, shippingData, paymentData", () => {
-			const id = "abc123";
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/${id}/coupons`, "POST")).toBe(
-				"checkout.orderform.coupons",
-			);
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/${id}/profile`, "POST")).toBe(
-				"checkout.orderform.profile",
-			);
-			expect(
-				vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/${id}/shippingData/...`, "POST"),
-			).toBe("checkout.orderform.shipping");
-			expect(
-				vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/${id}/paymentData/...`, "POST"),
-			).toBe("checkout.orderform.payment");
-		});
-
-		it("matches the singleton orderForm/{id} root with the right method", () => {
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/abc`, "GET")).toBe(
-				"checkout.orderform.get",
-			);
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/abc`, "PATCH")).toBe(
-				"checkout.orderform.update",
-			);
-		});
-
-		it("maps simulation, regions, postal-code", () => {
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForms/simulation`, "POST")).toBe(
-				"checkout.simulation",
-			);
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/regions`, "GET")).toBe(
-				"checkout.regions",
-			);
-			expect(vtexOperationRouter(`${acct}/api/checkout/pub/postal-code/BRA/01310`, "GET")).toBe(
-				"checkout.postal-code",
-			);
-		});
-	});
-
-	describe("Sessions + segments", () => {
-		it("differentiates sessions GET vs POST", () => {
-			expect(vtexOperationRouter(`${acct}/api/sessions`, "GET")).toBe("sessions.get");
-			expect(vtexOperationRouter(`${acct}/api/sessions`, "POST")).toBe("sessions.update");
-		});
-
-		it("matches segments", () => {
-			expect(vtexOperationRouter(`${acct}/api/segments/abc-123`, "GET")).toBe("segments.get");
-		});
-	});
-
-	describe("Catalog System", () => {
-		it("captures the most-specific catalog endpoints first", () => {
-			expect(
-				vtexOperationRouter(`${acct}/api/catalog_system/pub/portal/pagetype/eletronicos`, "GET"),
-			).toBe("catalog.pagetype");
-			expect(
-				vtexOperationRouter(
-					`${acct}/api/catalog_system/pub/products/crossselling/whoboughtalsobought/123`,
-					"GET",
-				),
-			).toBe("catalog.crossselling.whoboughtalsobought");
-			expect(
-				vtexOperationRouter(`${acct}/api/catalog_system/pub/products/variations/123`, "GET"),
-			).toBe("catalog.products.variations");
-			expect(
-				vtexOperationRouter(`${acct}/api/catalog_system/pub/products/search/?fq=x`, "GET"),
-			).toBe("catalog.products.search");
-			expect(vtexOperationRouter(`${acct}/api/catalog_system/pub/facets/search/x`, "GET")).toBe(
-				"catalog.facets.search",
-			);
-			expect(vtexOperationRouter(`${acct}/api/catalog_system/pub/category/tree/3`, "GET")).toBe(
-				"catalog.category.tree",
-			);
-			expect(
-				vtexOperationRouter(`${acct}/api/catalog_system/pvt/sku/stockkeepingunitbyid/123`, "GET"),
-			).toBe("catalog.sku");
-		});
-
-		it("falls back to catalog.other for unrecognized catalog paths", () => {
-			expect(
-				vtexOperationRouter(`${acct}/api/catalog_system/pvt/specification/groupGet/123`, "GET"),
-			).toBe("catalog.specification");
-			expect(vtexOperationRouter(`${acct}/api/catalog_system/pub/brand/list`, "GET")).toBe(
-				"catalog.brand",
-			);
-		});
-	});
-
-	describe("Masterdata", () => {
-		it("encodes the entity name as the operation suffix", () => {
-			expect(vtexOperationRouter(`${acct}/api/dataentities/AD/search`, "GET")).toBe(
-				"masterdata.AD",
-			);
-			expect(vtexOperationRouter(`${acct}/api/dataentities/wishlist_lists/documents`, "POST")).toBe(
-				"masterdata.wishlist_lists",
-			);
-		});
-	});
-
-	describe("OMS", () => {
-		it("differentiates orders list vs cancel", () => {
-			expect(vtexOperationRouter(`${acct}/api/oms/user/orders`, "GET")).toBe("oms.orders");
-			expect(vtexOperationRouter(`${acct}/api/oms/user/orders/v999-01/cancel`, "POST")).toBe(
-				"oms.orders.cancel",
-			);
-			expect(vtexOperationRouter(`${acct}/api/oms/pvt/orders/v999-01`, "GET")).toBe(
-				"oms.orders.pvt",
-			);
-		});
-	});
-
-	describe("VTEX ID", () => {
-		it("maps the auth surface", () => {
-			expect(vtexOperationRouter(`${acct}/api/vtexid/pub/logout?scope=x`, "GET")).toBe(
-				"vtexid.logout",
-			);
-			expect(vtexOperationRouter(`${acct}/api/vtexid/pub/authentication/start`, "GET")).toBe(
-				"vtexid.authentication.start",
-			);
-			expect(
-				vtexOperationRouter(`${acct}/api/vtexid/pub/authentication/classic/validate`, "POST"),
-			).toBe("vtexid.authentication.validate");
-			expect(vtexOperationRouter(`${acct}/api/vtexid/pub/authenticated/user`, "GET")).toBe(
-				"vtexid.user",
-			);
-		});
-
-		it("falls back to vtexid.other for unmapped vtexid paths", () => {
-			expect(vtexOperationRouter(`${acct}/api/vtexid/pub/refreshtoken`, "POST")).toBe(
-				"vtexid.other",
-			);
-		});
-	});
-
-	describe("VTEX IO + GraphQL", () => {
-		it("matches the IO private graphql endpoint", () => {
-			expect(vtexOperationRouter(`https://store.myvtex.com/_v/private/graphql/v1`, "POST")).toBe(
-				"io.graphql",
-			);
-		});
-
-		it("matches the IO segment endpoint", () => {
-			expect(
-				vtexOperationRouter(`https://store.myvtex.com/_v/segment/admin-pvt/whatever`, "GET"),
-			).toBe("io.segment");
-		});
-	});
-
-	describe("Edge cases", () => {
-		it("returns undefined for fully unrecognized URLs", () => {
-			expect(vtexOperationRouter(`${acct}/somethingelse/random`, "GET")).toBeUndefined();
-		});
-
-		it("does not throw on unparseable URLs and still tries to match", () => {
-			expect(vtexOperationRouter("not-a-real-url", "GET")).toBeUndefined();
-			expect(vtexOperationRouter("/api/sessions?x=1", "GET")).toBe("sessions.get");
-		});
-
-		it("is case-insensitive on the method", () => {
-			expect(vtexOperationRouter(`${acct}/api/sessions`, "post")).toBe("sessions.update");
-			expect(vtexOperationRouter(`${acct}/api/sessions`, "Get")).toBe("sessions.get");
-		});
-
-		it("recognizes sitemap.xml + sitemap-products-0.xml", () => {
-			expect(vtexOperationRouter(`${acct}/sitemap.xml`, "GET")).toBe("sitemap");
-			expect(vtexOperationRouter(`${acct}/sitemap-products-0.xml`, "GET")).toBe("sitemap");
-		});
-	});
-});

package/src/utils/__tests__/resilience.test.ts

@@ -1,205 +0,0 @@
-import { RequestContext } from "@decocms/blocks/sdk/requestContext";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  createResilientFetch,
-  isNonRetryableVtexError,
-  resetResilienceState,
-  VtexCircuitOpenError,
-  VtexTimeoutError,
-} from "../resilience";
-
-function res(status: number, body = "ok"): Response {
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    statusText: "",
-    json: async () => body,
-  } as Response;
-}
-
-beforeEach(() => {
-  resetResilienceState();
-});
-
-describe("createResilientFetch", () => {
-  it("passes a healthy GET through untouched, no retry", async () => {
-    const underlying = vi.fn(async () => res(200, "prod"));
-    const rf = createResilientFetch(underlying as unknown as typeof fetch);
-    const r = await rf("https://acct.vtexcommercestable.com.br/ok");
-    expect(r.status).toBe(200);
-    expect(underlying).toHaveBeenCalledOnce();
-  });
-
-  it("never retries a POST (mutation), even on 5xx", async () => {
-    const underlying = vi.fn(async () => res(500));
-    const rf = createResilientFetch(underlying as unknown as typeof fetch);
-    const r = await rf("https://acct.vtexcommercestable.com.br/checkout", {
-      method: "POST",
-      body: "{}",
-    });
-    expect(r.status).toBe(500);
-    expect(underlying).toHaveBeenCalledOnce();
-  });
-
-  it("retries an idempotent GET on a thrown network error, then succeeds", async () => {
-    let n = 0;
-    const underlying = vi.fn(async () => {
-      n++;
-      if (n < 3) throw new Error("ECONNRESET");
-      return res(200);
-    });
-    const rf = createResilientFetch(underlying as unknown as typeof fetch, {
-      backoffBaseMs: 1,
-      backoffCapMs: 2,
-    });
-    const r = await rf("https://acct.vtexcommercestable.com.br/search");
-    expect(r.status).toBe(200);
-    expect(underlying).toHaveBeenCalledTimes(3);
-  });
-
-  it("opens the circuit after N consecutive failures and then fails fast", async () => {
-    const underlying = vi.fn(async () => res(503));
-    const rf = createResilientFetch(underlying as unknown as typeof fetch, {
-      breakerConsecutiveFailures: 5,
-    });
-    const host = "https://acct.vtexcommercestable.com.br";
-    // 5 POSTs (1 attempt each) → 5 consecutive breaker failures → open.
-    for (let i = 0; i < 5; i++) {
-      await rf(`${host}/p`, { method: "POST", body: "x" });
-    }
-    const before = underlying.mock.calls.length;
-    await expect(rf(`${host}/p`, { method: "POST", body: "x" })).rejects.toBeInstanceOf(
-      VtexCircuitOpenError,
-    );
-    // Fail-fast must not touch the origin.
-    expect(underlying.mock.calls.length).toBe(before);
-  });
-
-  it("half-opens after cooldown and closes on a successful probe", async () => {
-    vi.useFakeTimers();
-    try {
-      let healthy = false;
-      const underlying = vi.fn(async () => (healthy ? res(200) : res(503)));
-      const rf = createResilientFetch(underlying as unknown as typeof fetch, {
-        breakerConsecutiveFailures: 3,
-        breakerOpenCooldownMs: 5_000,
-      });
-      const host = "https://acct.vtexcommercestable.com.br";
-      for (let i = 0; i < 3; i++) await rf(`${host}/p`, { method: "POST", body: "x" });
-      // Open now → fail fast.
-      await expect(rf(`${host}/p`, { method: "POST", body: "x" })).rejects.toBeInstanceOf(
-        VtexCircuitOpenError,
-      );
-      // After cooldown, a probe is allowed; make it succeed.
-      healthy = true;
-      await vi.advanceTimersByTimeAsync(5_001);
-      const r = await rf(`${host}/p`, { method: "POST", body: "x" });
-      expect(r.status).toBe(200);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("aborts a hung request with the per-attempt timeout", async () => {
-    vi.useFakeTimers();
-    try {
-      const underlying = vi.fn(
-        (_input: RequestInfo | URL, init?: RequestInit) =>
-          new Promise<Response>((_resolve, reject) => {
-            init?.signal?.addEventListener("abort", () =>
-              reject(Object.assign(new Error("aborted"), { name: "AbortError" })),
-            );
-          }),
-      );
-      const rf = createResilientFetch(underlying as unknown as typeof fetch, {
-        maxRetries: 0,
-        perAttemptTimeoutMs: 8_000,
-      });
-      const p = rf("https://acct.vtexcommercestable.com.br/hung");
-      p.catch(() => {});
-      await vi.advanceTimersByTimeAsync(8_001);
-      await expect(p).rejects.toBeInstanceOf(VtexTimeoutError);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("aborts an in-flight VTEX call when the ambient request signal aborts", async () => {
-    const ac = new AbortController();
-    const request = new Request("https://store.example/page", { signal: ac.signal });
-    const underlying = vi.fn(
-      (_input: RequestInfo | URL, init?: RequestInit) =>
-        new Promise<Response>((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () =>
-            reject(Object.assign(new Error("aborted"), { name: "AbortError" })),
-          );
-        }),
-    );
-    const rf = createResilientFetch(underlying as unknown as typeof fetch, {
-      maxRetries: 0,
-      perAttemptTimeoutMs: 60_000,
-    });
-
-    await RequestContext.run(request, async () => {
-      const p = rf("https://acct.vtexcommercestable.com.br/slow");
-      p.catch(() => {});
-      ac.abort();
-      await expect(p).rejects.toThrow();
-    });
-    expect(underlying).toHaveBeenCalled();
-  });
-
-  it("does NOT count an external (caller/ambient) abort as a breaker failure", async () => {
-    const underlying = vi.fn(
-      (_input: RequestInfo | URL, init?: RequestInit) =>
-        new Promise<Response>((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () =>
-            reject(Object.assign(new Error("aborted"), { name: "AbortError" })),
-          );
-        }),
-    );
-    const host = "https://acct.vtexcommercestable.com.br";
-    const rf = createResilientFetch(underlying as unknown as typeof fetch, {
-      maxRetries: 0,
-      breakerConsecutiveFailures: 3,
-    });
-
-    // Abort 5 caller requests (> the 3-failure threshold). If these counted as
-    // breaker failures, the circuit would open against a healthy upstream.
-    for (let i = 0; i < 5; i++) {
-      const ac = new AbortController();
-      const p = rf(`${host}/x`, { signal: ac.signal });
-      p.catch(() => {});
-      ac.abort();
-      await expect(p).rejects.toThrow();
-    }
-
-    // Breaker must still be CLOSED: a healthy call succeeds (not VtexCircuitOpenError).
-    const healthy = createResilientFetch((async () => res(200)) as unknown as typeof fetch);
-    const r = await healthy(`${host}/x`);
-    expect(r.status).toBe(200);
-  });
-
-  it("honors the kill-switch env var", async () => {
-    const prev = process.env.VTEX_RESILIENCE_DISABLED;
-    process.env.VTEX_RESILIENCE_DISABLED = "true";
-    try {
-      const underlying = vi.fn(async () => res(200));
-      const rf = createResilientFetch(underlying as unknown as typeof fetch);
-      await rf("https://acct.vtexcommercestable.com.br/x", { method: "POST", body: "y" });
-      expect(underlying).toHaveBeenCalledOnce();
-    } finally {
-      if (prev === undefined) delete process.env.VTEX_RESILIENCE_DISABLED;
-      else process.env.VTEX_RESILIENCE_DISABLED = prev;
-    }
-  });
-});
-
-describe("isNonRetryableVtexError", () => {
-  it("flags circuit-open and timeout errors, not generic ones", () => {
-    expect(isNonRetryableVtexError(new VtexCircuitOpenError("h"))).toBe(true);
-    expect(isNonRetryableVtexError(new VtexTimeoutError("h", 1))).toBe(true);
-    expect(isNonRetryableVtexError(new Error("boom"))).toBe(false);
-    expect(isNonRetryableVtexError(null)).toBe(false);
-  });
-});

package/src/utils/__tests__/resourceRange.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resourceRange } from "../resourceRange";
-
-describe("resourceRange", () => {
-	it("returns from=0 and to=take when skip is 0", () => {
-		expect(resourceRange(0, 50)).toEqual({ from: 0, to: 50 });
-	});
-
-	it("caps take at 100", () => {
-		expect(resourceRange(0, 200)).toEqual({ from: 0, to: 100 });
-	});
-
-	it("applies skip offset", () => {
-		expect(resourceRange(10, 50)).toEqual({ from: 10, to: 60 });
-	});
-
-	it("handles skip + take > 100 by capping take", () => {
-		expect(resourceRange(50, 200)).toEqual({ from: 50, to: 150 });
-	});
-
-	it("treats negative skip as 0", () => {
-		expect(resourceRange(-5, 10)).toEqual({ from: 0, to: 10 });
-	});
-
-	it("handles zero take", () => {
-		expect(resourceRange(0, 0)).toEqual({ from: 0, to: 0 });
-	});
-
-	it("handles take of exactly 100", () => {
-		expect(resourceRange(0, 100)).toEqual({ from: 0, to: 100 });
-	});
-});

package/src/utils/__tests__/simulationCache.test.ts

@@ -1,40 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	__resetSimulationCacheForTests,
-	getSimulationCache,
-	setSimulationCache,
-} from "../simulationCache";
-
-describe("simulationCache (#373)", () => {
-	afterEach(() => {
-		__resetSimulationCacheForTests();
-	});
-
-	it("default in-process cache: returns null on miss, then the value after put", async () => {
-		const cache = getSimulationCache();
-		expect(await cache.get("k")).toBeNull();
-		await cache.put("k", "v", 60);
-		expect(await cache.get("k")).toBe("v");
-	});
-
-	it("expires an entry past its TTL", async () => {
-		const cache = getSimulationCache();
-		await cache.put("k", "v", 0); // already expired
-		await new Promise((r) => setTimeout(r, 5));
-		expect(await cache.get("k")).toBeNull();
-	});
-
-	it("setSimulationCache injects a custom implementation", async () => {
-		const store = new Map<string, string>();
-		setSimulationCache({
-			get: (k) => store.get(k) ?? null,
-			put: (k, v) => {
-				store.set(k, v);
-			},
-		});
-		const cache = getSimulationCache();
-		await cache.put("k", "custom-value", 60);
-		expect(await cache.get("k")).toBe("custom-value");
-		expect(store.get("k")).toBe("custom-value");
-	});
-});

package/src/utils/__tests__/sitemap.test.ts

@@ -1,185 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { configureVtex } from "../../client";
-import { createVtexSitemapProxy, isVtexSitemapPath } from "../sitemap";
-
-const ACCOUNT = "myaccount";
-const VTEX_HOST = `${ACCOUNT}.vtexcommercestable.com.br`;
-
-beforeEach(() => {
-	configureVtex({ account: ACCOUNT });
-});
-
-afterEach(() => {
-	vi.restoreAllMocks();
-});
-
-describe("isVtexSitemapPath", () => {
-	it.each([
-		["/sitemap.xml", true],
-		["/sitemap/products-1.xml", true],
-		["/sitemap/category-3.xml", true],
-		["/sitemap/", true],
-		["/sitemap", false],
-		["/", false],
-		["/checkout", false],
-		["/sitemap-busca.xml", false],
-	])("%s → %s", (pathname, expected) => {
-		expect(isVtexSitemapPath(pathname)).toBe(expected);
-	});
-});
-
-describe("createVtexSitemapProxy", () => {
-	function makeFetch(
-		responseBody: string,
-		init: { status?: number; ok?: boolean } = {},
-	): typeof fetch {
-		const status = init.status ?? 200;
-		return vi.fn(
-			async () =>
-				new Response(responseBody, {
-					status,
-					headers: { "content-type": "application/xml" },
-				}),
-		) as unknown as typeof fetch;
-	}
-
-	const SITEMAP_INDEX = `<?xml version="1.0" encoding="UTF-8"?>
-<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  <sitemap><loc>https://${VTEX_HOST}/sitemap/products-1.xml</loc></sitemap>
-  <sitemap><loc>https://${VTEX_HOST}/sitemap/category-1.xml</loc></sitemap>
-</sitemapindex>`;
-
-	const PRODUCT_SUB_SITEMAP = `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  <url><loc>https://${VTEX_HOST}/p/some-product/p</loc></url>
-</urlset>`;
-
-	it("returns null for non-sitemap paths", async () => {
-		const proxy = createVtexSitemapProxy({ fetchImpl: makeFetch("") });
-		const url = new URL("https://www.mystore.com/checkout");
-		await expect(proxy(new Request(url), url)).resolves.toBeNull();
-	});
-
-	it("proxies /sitemap.xml and rewrites VTEX hostname to storefront origin", async () => {
-		const fetchImpl = makeFetch(SITEMAP_INDEX);
-		const proxy = createVtexSitemapProxy({ fetchImpl });
-		const url = new URL("https://www.mystore.com/sitemap.xml");
-
-		const res = await proxy(new Request(url), url);
-
-		expect(res).not.toBeNull();
-		expect(res!.status).toBe(200);
-		expect(res!.headers.get("content-type")).toBe("application/xml; charset=utf-8");
-		expect(fetchImpl).toHaveBeenCalledWith(`https://${VTEX_HOST}/sitemap.xml`);
-
-		const xml = await res!.text();
-		expect(xml).not.toContain(VTEX_HOST);
-		expect(xml).toContain("https://www.mystore.com/sitemap/products-1.xml");
-		expect(xml).toContain("https://www.mystore.com/sitemap/category-1.xml");
-	});
-
-	it("proxies /sitemap/* sub-sitemaps with hostname rewrite", async () => {
-		const fetchImpl = makeFetch(PRODUCT_SUB_SITEMAP);
-		const proxy = createVtexSitemapProxy({ fetchImpl });
-		const url = new URL("https://www.mystore.com/sitemap/products-1.xml");
-
-		const res = await proxy(new Request(url), url);
-
-		expect(res).not.toBeNull();
-		expect(fetchImpl).toHaveBeenCalledWith(`https://${VTEX_HOST}/sitemap/products-1.xml`);
-		const xml = await res!.text();
-		expect(xml).toContain("https://www.mystore.com/p/some-product/p");
-		expect(xml).not.toContain(VTEX_HOST);
-	});
-
-	it("injects extraSitemaps entries into /sitemap.xml only", async () => {
-		const fetchImpl = makeFetch(SITEMAP_INDEX);
-		const proxy = createVtexSitemapProxy({
-			fetchImpl,
-			extraSitemaps: ["/sitemap-busca.xml", "extra-bare", "https://cdn.example.com/static.xml"],
-		});
-		const url = new URL("https://www.mystore.com/sitemap.xml");
-		const xml = await (await proxy(new Request(url), url))!.text();
-
-		expect(xml).toContain("<loc>https://www.mystore.com/sitemap-busca.xml</loc>");
-		expect(xml).toContain("<loc>https://www.mystore.com/extra-bare</loc>");
-		expect(xml).toContain("<loc>https://cdn.example.com/static.xml</loc>");
-		// Extra entries are inserted before the closing tag (i.e. inside the index).
-		expect(xml.indexOf("sitemap-busca.xml")).toBeLessThan(xml.indexOf("</sitemapindex>"));
-	});
-
-	it("does not inject extraSitemaps into sub-sitemaps", async () => {
-		const fetchImpl = makeFetch(PRODUCT_SUB_SITEMAP);
-		const proxy = createVtexSitemapProxy({
-			fetchImpl,
-			extraSitemaps: ["/sitemap-busca.xml"],
-		});
-		const url = new URL("https://www.mystore.com/sitemap/products-1.xml");
-		const xml = await (await proxy(new Request(url), url))!.text();
-
-		expect(xml).not.toContain("sitemap-busca.xml");
-	});
-
-	it("returns 502 when VTEX origin returns non-OK", async () => {
-		const fetchImpl = makeFetch("upstream is down", { status: 503 });
-		const proxy = createVtexSitemapProxy({ fetchImpl });
-		const url = new URL("https://www.mystore.com/sitemap.xml");
-		const res = await proxy(new Request(url), url);
-		expect(res!.status).toBe(502);
-	});
-
-	it("returns 502 when fetch throws", async () => {
-		const fetchImpl = vi.fn(async () => {
-			throw new Error("network down");
-		}) as unknown as typeof fetch;
-		const proxy = createVtexSitemapProxy({ fetchImpl });
-		const url = new URL("https://www.mystore.com/sitemap.xml");
-		const res = await proxy(new Request(url), url);
-		expect(res!.status).toBe(502);
-	});
-
-	it("uses the configured environment", async () => {
-		const fetchImpl = makeFetch(SITEMAP_INDEX);
-		const proxy = createVtexSitemapProxy({
-			fetchImpl,
-			environment: "vtexcommercebeta",
-		});
-		const url = new URL("https://www.mystore.com/sitemap.xml");
-		await proxy(new Request(url), url);
-
-		expect(fetchImpl).toHaveBeenCalledWith(
-			`https://${ACCOUNT}.vtexcommercebeta.com.br/sitemap.xml`,
-		);
-	});
-
-	it("honors a custom Cache-Control header", async () => {
-		const fetchImpl = makeFetch(SITEMAP_INDEX);
-		const proxy = createVtexSitemapProxy({
-			fetchImpl,
-			cacheControl: "public, max-age=60",
-		});
-		const url = new URL("https://www.mystore.com/sitemap.xml");
-		const res = await proxy(new Request(url), url);
-		expect(res!.headers.get("cache-control")).toBe("public, max-age=60");
-	});
-
-	it("emits the default Cache-Control by default", async () => {
-		const fetchImpl = makeFetch(SITEMAP_INDEX);
-		const proxy = createVtexSitemapProxy({ fetchImpl });
-		const url = new URL("https://www.mystore.com/sitemap.xml");
-		const res = await proxy(new Request(url), url);
-		expect(res!.headers.get("cache-control")).toBe(
-			"public, s-maxage=3600, stale-while-revalidate=86400",
-		);
-	});
-
-	it("respects non-default VTEX domain (e.g. .com)", async () => {
-		configureVtex({ account: ACCOUNT, domain: "com" });
-		const fetchImpl = makeFetch(SITEMAP_INDEX);
-		const proxy = createVtexSitemapProxy({ fetchImpl });
-		const url = new URL("https://www.mystore.com/sitemap.xml");
-		await proxy(new Request(url), url);
-
-		expect(fetchImpl).toHaveBeenCalledWith(`https://${ACCOUNT}.vtexcommercestable.com/sitemap.xml`);
-	});
-});