@drip-apex/sdk 0.1.0

package/src/commerce-config-lifecycle.test.ts

@@ -0,0 +1,274 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  commerceAssignmentResponseFixture,
+  commercePriceFixture as commerce,
+  installCommerceProductPage,
+  priceExperimentsFixture as experiments,
+} from "./test-fixtures/commerce";
+
+function makeStorage(): Storage {
+  const values = new Map<string, string>();
+  return {
+    get length() { return values.size; },
+    clear: () => values.clear(),
+    getItem: (key) => values.get(key) ?? null,
+    key: (index) => Array.from(values.keys())[index] ?? null,
+    removeItem: (key) => { values.delete(key); },
+    setItem: (key, value) => { values.set(key, value); },
+  };
+}
+
+async function waitForPrice(expected: string) {
+  for (let attempt = 0; attempt < 500; attempt += 1) {
+    if (document.querySelector(".price")?.textContent === expected) return;
+    await new Promise((resolve) => setTimeout(resolve, 1));
+  }
+  expect(document.querySelector(".price")?.textContent).toBe(expected);
+}
+
+describe("commerce config lifecycle", () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    vi.resetModules();
+    delete (globalThis as typeof globalThis & { __drip?: unknown }).__drip;
+    Object.defineProperty(globalThis, "localStorage", {
+      configurable: true,
+      value: makeStorage(),
+    });
+    Object.defineProperty(globalThis, "sessionStorage", {
+      configurable: true,
+      value: makeStorage(),
+    });
+    installCommerceProductPage();
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes("/config")) {
+        return new Response(JSON.stringify({ experiments }), { status: 200 });
+      }
+      if (url.includes("/v1/assign")) {
+        return new Response(JSON.stringify(commerceAssignmentResponseFixture), { status: 200 });
+      }
+      return new Response("ok", { status: 202 });
+    }) as typeof fetch;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    delete (globalThis as typeof globalThis & { __drip?: unknown }).__drip;
+    globalThis.fetch = originalFetch;
+    delete (window as Window & { Shopify?: unknown }).Shopify;
+    delete (window as Window & { ShopifyAnalytics?: unknown }).ShopifyAnalytics;
+    document.head.innerHTML = "";
+    document.body.innerHTML = "";
+  });
+
+  it("tears down a cached price plane before an authoritative removal can write stale cart state", async () => {
+    const hash = JSON.stringify({
+      experiments,
+      profile: null,
+      runtime: null,
+      signals: [],
+      commerce,
+    });
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash,
+      experiments,
+      commerce,
+    }));
+    let resolveConfig!: (response: Response) => void;
+    let resolveStaleAuthorization!: (response: Response) => void;
+    let authorizationCalls = 0;
+    const fetchMock = vi.fn((input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes("/config")) {
+        return new Promise<Response>((resolve) => { resolveConfig = resolve; });
+      }
+      if (url.endsWith("/cart.js")) {
+        return Promise.resolve(Response.json({ token: "cart-runtime?key=runtime-secret" }));
+      }
+      if (url.includes("/v1/assign")) {
+        authorizationCalls += 1;
+        if (authorizationCalls === 1) {
+          return Promise.resolve(Response.json(commerceAssignmentResponseFixture));
+        }
+        return new Promise<Response>((resolve) => { resolveStaleAuthorization = resolve; });
+      }
+      return Promise.resolve(new Response("ok", { status: 200 }));
+    });
+    globalThis.fetch = fetchMock as typeof fetch;
+    const disconnect = vi.spyOn(MutationObserver.prototype, "disconnect");
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      ingestSignature: "ingest-token",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+    });
+    await vi.waitFor(() => {
+      expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+      expect(getDiagnostics().spa.lastShopifyCartSync?.status).toBe("sent");
+    });
+
+    const cartWritesBeforeRemoval = fetchMock.mock.calls.filter(
+      ([url]) => url === "/cart/update.js",
+    ).length;
+    await window.fetch("/cart/add.js", { method: "POST" });
+    await vi.waitFor(() => {
+      expect(authorizationCalls).toBe(2);
+      expect(getDiagnostics().spa.lastShopifyCartSync?.status).toBe("pending");
+    });
+
+    resolveConfig(Response.json({ experiments }));
+
+    await vi.waitFor(
+      () => expect(getDiagnostics().configSource).toBe("network"),
+      { timeout: 5_000, interval: 10 },
+    );
+    await waitForPrice("€1.299,00");
+    expect(disconnect).toHaveBeenCalled();
+
+    resolveStaleAuthorization(Response.json(commerceAssignmentResponseFixture));
+    await vi.waitFor(() => {
+      expect(fetchMock.mock.calls.filter(
+        ([url]) => url === "/cart/update.js",
+      )).toHaveLength(cartWritesBeforeRemoval);
+    });
+    const cached = JSON.parse(localStorage.getItem("drip_cfg:shop_123:production") ?? "{}");
+    expect(cached).not.toHaveProperty("commerce");
+    expect(cached.hash).toContain('"commerce":null');
+  });
+
+  it("keeps the no-state, no-plane lazy path free of price cleanup", async () => {
+    const commercePrice = await import("./commerce-price");
+    const cleanup = vi.spyOn(commercePrice, "cleanupCommercePrice");
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).includes("/config")
+        ? Response.json({ experiments: [] })
+        : new Response("ok", { status: 202 })) as typeof fetch;
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      ingestSignature: "ingest-token",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+    });
+
+    await vi.waitFor(() => expect(getDiagnostics().configSource).toBe("network"));
+    expect(cleanup).not.toHaveBeenCalled();
+  });
+
+  it("keeps an active cached price plane applied when the authoritative plane remains", async () => {
+    const hash = JSON.stringify({
+      experiments,
+      profile: null,
+      runtime: null,
+      signals: [],
+      commerce,
+    });
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash,
+      experiments,
+      commerce,
+    }));
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes("/config")) {
+        return Response.json({
+          experiments,
+          commerce,
+          profile: { platform: "shopify", version: 1 },
+        });
+      }
+      if (url.endsWith("/cart.js")) {
+        return Response.json({ token: "cart-runtime?key=runtime-secret" });
+      }
+      if (url.includes("/v1/assign")) {
+        return Response.json(commerceAssignmentResponseFixture);
+      }
+      return new Response("ok", { status: 200 });
+    }) as typeof fetch;
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      ingestSignature: "ingest-token",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+    });
+
+    await vi.waitFor(() => {
+      expect(getDiagnostics().configSource).toBe("network");
+      expect(document.querySelector(".price")?.textContent).toBe("€1.149,95");
+    });
+  });
+
+  it("clears a stale shipping authorization after the Worker confirms the assignment disappeared", async () => {
+    sessionStorage.setItem("drip_cart_attr", JSON.stringify({
+      assignments: [["exp_shipping", "treatment", 6]],
+      requiredAssignments: [["exp_shipping", "treatment", 6]],
+      visitorId: "visitor_123",
+      sessionId: "session_old",
+      shippingAuthorizationRevision: 6,
+      priceAuthorizationRevision: null,
+    }));
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes("/v1/assign")) {
+        return Response.json({ assignments: [] });
+      }
+      return new Response("ok", { status: 200 });
+    });
+    globalThis.fetch = fetchMock as typeof fetch;
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce: {
+        shipping: {
+          authorization: {
+            version: 1,
+            revision: 7,
+            checksum: "a".repeat(64),
+            experimentIds: ["exp_shipping"],
+          },
+          experiments: [],
+        },
+      },
+      endpoint: "https://events.test",
+      experiments: [],
+      ingestSignature: "ingest-token",
+      runtimeProfile: "full",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_123",
+    });
+
+    await vi.waitFor(() =>
+      expect(fetchMock.mock.calls.map(([url]) => String(url))).toContain("/cart/update.js"),
+    );
+    const authorizationRequest = fetchMock.mock.calls.find(([url]) =>
+      String(url).includes("/v1/assign")
+    );
+    expect(authorizationRequest).toBeDefined();
+    expect(JSON.parse(String(authorizationRequest?.[1]?.body))).toMatchObject({
+      experiments: [],
+    });
+    const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
+    expect(JSON.parse(String(cartUpdate?.[1]?.body)).attributes).toMatchObject({
+      apex_assignments: "[]",
+      apex_assignment_authorization: "",
+      apex_experiment_id: "",
+      apex_variation_id: "",
+      apex_assignment_epoch: "",
+    });
+  });
+});

package/src/commerce-epoch-lifecycle.test.ts

@@ -0,0 +1,62 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  commercePriceFixture as commerce,
+  installCommerceProductPage,
+  priceExperimentsFixture as experiments,
+} from "./test-fixtures/commerce";
+
+describe("commerce assignment epoch lifecycle", () => {
+  const originalFetch = globalThis.fetch;
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.resetModules();
+    installCommerceProductPage();
+    fetchMock = vi.fn(async (input: RequestInfo | URL) =>
+      String(input).endsWith("/cart.js")
+        ? Response.json({ token: "cart-epoch?key=epoch-secret" })
+        : String(input).includes("/v1/assign")
+        ? new Response(JSON.stringify({
+          assignments: [{
+            experiment_id: "exp_price",
+            variation_id: "treatment",
+            assignment_epoch: 2,
+          }],
+          commerce_authorization: "signed",
+        }), { status: 200 })
+        : new Response("ok", { status: 202 }));
+    globalThis.fetch = fetchMock as typeof fetch;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    globalThis.fetch = originalFetch;
+    delete (window as Window & { Shopify?: unknown }).Shopify;
+    delete (window as Window & { ShopifyAnalytics?: unknown }).ShopifyAnalytics;
+    document.head.innerHTML = "";
+    document.body.innerHTML = "";
+  });
+
+  it("keeps the published price when the Worker rejects a stale assignment epoch", async () => {
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments,
+      ingestSignature: "ingest-token",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    await vi.waitFor(() =>
+      expect(fetchMock.mock.calls.some(([url]) => String(url).includes("/v1/assign")))
+        .toBe(true));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    const cartWrite = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
+    expect(cartWrite).toBeUndefined();
+    expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
+  });
+});