@drip-apex/sdk 0.1.0

package/src/targeting.detailed.test.ts

@@ -0,0 +1,443 @@
+import { describe, expect, it } from "vitest";
+import { build } from "esbuild";
+import { evaluateTargetingGates, evaluateTargetingGatesDetailed } from "./targeting";
+import type { Targeting } from "./types";
+
+describe("evaluateTargetingGatesDetailed", () => {
+  it("uses aggregate targeting gates with empty conditions for live builds", async () => {
+    const liveBuild = await build({
+      entryPoints: ["src/targeting.ts"],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      write: false,
+      define: {
+        __DRIP_QA_BUILD__: "false",
+      },
+    });
+    const liveModuleUrl = `data:text/javascript;base64,${Buffer.from(liveBuild.outputFiles[0].text).toString("base64")}`;
+    const liveTargeting = await import(/* @vite-ignore */ liveModuleUrl) as typeof import("./targeting");
+
+    const cases: Array<{
+      name: string;
+      targeting?: Targeting;
+      ctx: { url: string; attributes: Record<string, unknown> };
+    }> = [
+      {
+        name: "matched url, attributes, and segments",
+        targeting: {
+          url: [{ type: "simple", pattern: "/products/*" }],
+          attributes: [{ attribute: "plan", operator: "equals", value: "pro" }],
+          segmentRules: [
+            {
+              id: "segment_1",
+              rules: {
+                version: 1,
+                operator: "and",
+                conditions: [{ signal: "cart.item_count", operator: "greater_than", value: 0 }],
+              },
+            },
+          ],
+        },
+        ctx: {
+          url: "https://shop.test/products/shirt",
+          attributes: { plan: "pro", "cart.item_count": 3 },
+        },
+      },
+      {
+        name: "page mismatch skips audience",
+        targeting: {
+          url: [{ type: "simple", pattern: "/products/*" }],
+          attributes: [{ attribute: "plan", operator: "equals", value: "pro" }],
+        },
+        ctx: {
+          url: "https://shop.test/pages/about",
+          attributes: { plan: "pro" },
+        },
+      },
+      {
+        name: "named query condition keeps aggregate precedence over js",
+        targeting: {
+          segmentRules: [
+            {
+              id: "query_segment",
+              rules: {
+                version: 1,
+                operator: "and",
+                conditions: [{
+                  signal: "url.query",
+                  operator: "equals",
+                  value: "utm=spring",
+                  js: { code: "return false;" },
+                }],
+              },
+            },
+          ],
+        },
+        ctx: {
+          url: "https://shop.test/?utm=spring",
+          attributes: {},
+        },
+      },
+      {
+        name: "no targeting",
+        targeting: undefined,
+        ctx: {
+          url: "https://shop.test/",
+          attributes: {},
+        },
+      },
+    ];
+
+    for (const testCase of cases) {
+      const aggregate = evaluateTargetingGates(testCase.targeting, testCase.ctx);
+      const liveFallback = liveTargeting.evaluateTargetingGatesDetailed(
+        testCase.targeting,
+        testCase.ctx,
+      );
+      expect(liveFallback, testCase.name).toEqual({ ...aggregate, conditions: [] });
+
+      const qaDetailed = evaluateTargetingGatesDetailed(testCase.targeting, testCase.ctx);
+      expect(qaDetailed.matched, `${testCase.name} (qa matched)`).toBe(aggregate.matched);
+      expect(qaDetailed.gates, `${testCase.name} (qa gates)`).toEqual(aggregate.gates);
+    }
+  });
+
+  it("reports URL rule match and mismatch conditions", () => {
+    const targeting: Targeting = {
+      url: [{ type: "simple", pattern: "/products/*" }],
+    };
+
+    const matched = evaluateTargetingGatesDetailed(targeting, {
+      url: "https://shop.test/products/shirt",
+      attributes: {},
+    });
+    expect(matched.matched).toBe(true);
+    expect(matched.conditions).toEqual([
+      expect.objectContaining({
+        id: "url:0",
+        status: "passed",
+        sourceType: "url",
+        source: "/products/*",
+        expected: "/products/*",
+        actual: "https://shop.test/products/shirt",
+      }),
+    ]);
+
+    const mismatched = evaluateTargetingGatesDetailed(targeting, {
+      url: "https://shop.test/pages/about",
+      attributes: {},
+    });
+    expect(mismatched.matched).toBe(false);
+    expect(mismatched.conditions[0]).toMatchObject({
+      id: "url:0",
+      status: "failed",
+      reason: "url_mismatch",
+      sourceType: "url",
+    });
+    expect(evaluateTargetingGates(targeting, {
+      url: "https://shop.test/pages/about",
+      attributes: {},
+    })).toMatchInlineSnapshot(`
+      {
+        "gates": [
+          {
+            "detail": {
+              "pageRules": 0,
+              "rules": 1,
+              "url": "https://shop.test/pages/about",
+            },
+            "id": "page",
+            "label": "Page check",
+            "reason": "url_mismatch",
+            "status": "failed",
+          },
+          {
+            "detail": {
+              "skipped": true,
+            },
+            "id": "audience",
+            "label": "Audience check",
+            "reason": "page_mismatch",
+            "status": "skipped",
+          },
+        ],
+        "matched": false,
+      }
+    `);
+  });
+
+  it("reports page-rule JS true, false, and error without throwing", () => {
+    const baseRule = {
+      id: "page_1",
+      includeRules: [{ type: "simple" as const, pattern: "/products/*", include: true }],
+    };
+
+    const jsTrue = evaluateTargetingGatesDetailed({
+      pageRules: [{ ...baseRule, advancedCondition: { code: "return true;" } }],
+    }, {
+      url: "https://shop.test/products/shirt",
+      attributes: {},
+    });
+    expect(jsTrue.conditions[0]).toMatchObject({
+      id: "page:page_1",
+      status: "passed",
+      sourceType: "js",
+      source: "return true;",
+      expected: JSON.stringify([{ include: true, matchType: "simple", pattern: "/products/*" }]),
+      actual: true,
+    });
+
+    const jsFalse = evaluateTargetingGatesDetailed({
+      pageRules: [{ ...baseRule, advancedCondition: { code: "false" } }],
+    }, {
+      url: "https://shop.test/products/shirt",
+      attributes: {},
+    });
+    expect(jsFalse.matched).toBe(false);
+    expect(jsFalse.conditions[0]).toMatchObject({
+      status: "failed",
+      reason: "js_false",
+      sourceType: "js",
+      source: "false",
+      actual: false,
+    });
+
+    const jsError = evaluateTargetingGatesDetailed({
+      pageRules: [{ ...baseRule, advancedCondition: { code: "throw new Error('bad trigger')" } }],
+    }, {
+      url: "https://shop.test/products/shirt",
+      attributes: {},
+    });
+    expect(jsError.matched).toBe(false);
+    expect(jsError.conditions[0]).toMatchObject({
+      status: "failed",
+      sourceType: "js",
+      source: "throw new Error('bad trigger')",
+      actual: false,
+    });
+    expect(jsError.conditions[0]?.reason).toContain("js_error");
+    expect(jsError.conditions[0]?.reason).toContain("bad trigger");
+  });
+
+  it("includes page URL patterns and the current URL in page-rule diagnostics", () => {
+    const diagnostics = evaluateTargetingGatesDetailed({
+      pageRules: [{
+        id: "products",
+        name: "Product detail pages",
+        includeRules: [{ type: "simple", pattern: "/products/*" }],
+        excludeRules: [{ type: "regex", pattern: "/products/sample$" }],
+      }],
+    }, { url: "https://shop.test/products/shirt", attributes: {} });
+
+    expect(diagnostics.conditions[0]).toMatchObject({
+      sourceType: "page_rule",
+      // Patterns live in source (rendered as Rules:); expected stays unset
+      // for plain page rules so the panel never duplicates them.
+      expected: undefined,
+      actual: "https://shop.test/products/shirt — passed",
+    });
+    expect(diagnostics.conditions[0]?.source).toContain('"include":true');
+    expect(diagnostics.conditions[0]?.source).toContain('"pattern":"/products/*"');
+    expect(diagnostics.conditions[0]?.source).toContain('"include":false');
+  });
+
+  it("reports page trigger JS as the raw JS source", () => {
+    const diagnostics = evaluateTargetingGatesDetailed({
+      pageRules: [
+        {
+          id: "page_1",
+          includeRules: [{ type: "simple", pattern: "/products/*", include: true }],
+          trigger: {
+            mode: "manual-callback",
+            signal: "page.trigger.pdp_overlay",
+            triggerJs: "activate();",
+          },
+        },
+      ],
+    }, {
+      url: "https://shop.test/products/shirt",
+      attributes: {},
+    });
+
+    expect(diagnostics.matched).toBe(false);
+    expect(diagnostics.conditions[0]).toMatchObject({
+      id: "page:page_1",
+      status: "failed",
+      reason: "manual_trigger_mismatch",
+      sourceType: "js",
+      source: "activate();",
+    });
+  });
+
+  it("reports attribute operator mismatches with expected and actual values", () => {
+    const diagnostics = evaluateTargetingGatesDetailed({
+      attributes: [{ attribute: "plan", operator: "equals", value: "pro" }],
+    }, {
+      url: "https://shop.test/",
+      attributes: { plan: "free" },
+    });
+
+    expect(diagnostics.matched).toBe(false);
+    expect(diagnostics.conditions).toContainEqual(expect.objectContaining({
+      id: "attribute:plan:0",
+      status: "failed",
+      reason: "attribute_mismatch",
+      sourceType: "attribute",
+      signal: "plan",
+      operator: "equals",
+      expected: "pro",
+      actual: "free",
+    }));
+  });
+
+  it("reports segment JS conditions with verbatim source", () => {
+    const source = "return attributes.plan === 'pro';";
+    const diagnostics = evaluateTargetingGatesDetailed({
+      segmentRules: [
+        {
+          id: "segment_1",
+          name: "Pro plan",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              {
+                signal: "plan.js",
+                operator: "equals",
+                value: true,
+                js: { code: source },
+              },
+            ],
+          },
+        },
+      ],
+    }, {
+      url: "https://shop.test/",
+      attributes: { plan: "pro" },
+    });
+
+    expect(diagnostics.matched).toBe(true);
+    expect(diagnostics.conditions).toContainEqual(expect.objectContaining({
+      id: "segment:segment_1:0",
+      status: "passed",
+      sourceType: "js",
+      source,
+      signal: "plan.js",
+      operator: "equals",
+      expected: true,
+      actual: true,
+    }));
+  });
+
+  it("marks audience conditions skipped after a page failure", () => {
+    const targeting: Targeting = {
+      url: [{ type: "simple", pattern: "/products/*" }],
+      attributes: [{ attribute: "plan", operator: "equals", value: "pro" }],
+      segmentRules: [
+        {
+          id: "segment_1",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [{ signal: "cart.item_count", operator: "greater_than", value: 0 }],
+          },
+        },
+      ],
+    };
+
+    const diagnostics = evaluateTargetingGatesDetailed(targeting, {
+      url: "https://shop.test/pages/about",
+      attributes: { plan: "pro", "cart.item_count": 3 },
+    });
+
+    expect(diagnostics.matched).toBe(false);
+    expect(diagnostics.conditions).toEqual([
+      expect.objectContaining({ id: "url:0", status: "failed", reason: "url_mismatch" }),
+      expect.objectContaining({ id: "attribute:plan:0", status: "skipped", reason: "page_mismatch" }),
+      expect.objectContaining({ id: "segment:segment_1:0", status: "skipped", reason: "page_mismatch" }),
+    ]);
+  });
+
+  it("marks grouped segment conditions skipped after a page failure", () => {
+    const diagnostics = evaluateTargetingGatesDetailed({
+      url: [{ type: "simple", pattern: "/products/*" }],
+      segmentRules: [
+        {
+          id: "segment_grouped",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [],
+            groups: [
+              [{ signal: "plan", operator: "equals", value: "pro" }],
+              [{ signal: "cart.item_count", operator: "greater_than", value: 0 }],
+            ],
+          },
+        },
+      ],
+    }, {
+      url: "https://shop.test/pages/about",
+      attributes: { plan: "pro", "cart.item_count": 3 },
+    });
+
+    expect(diagnostics.conditions).toEqual([
+      expect.objectContaining({ id: "url:0", status: "failed", reason: "url_mismatch" }),
+      expect.objectContaining({ id: "segment:segment_grouped:0", status: "skipped", reason: "page_mismatch" }),
+      expect.objectContaining({ id: "segment:segment_grouped:1", status: "skipped", reason: "page_mismatch" }),
+    ]);
+  });
+
+  it("reports all-pass targeting and preserves the aggregate gate output", () => {
+    const targeting: Targeting = {
+      url: [{ type: "simple", pattern: "/products/*" }],
+      attributes: [{ attribute: "plan", operator: "equals", value: "pro" }],
+      segmentRules: [
+        {
+          id: "segment_1",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [{ signal: "cart.item_count", operator: "greater_than", value: 0 }],
+          },
+        },
+      ],
+    };
+    const ctx = {
+      url: "https://shop.test/products/shirt",
+      attributes: { plan: "pro", "cart.item_count": 3 },
+    };
+
+    const diagnostics = evaluateTargetingGatesDetailed(targeting, ctx);
+    expect(diagnostics.matched).toBe(true);
+    expect(diagnostics.conditions.map((condition) => condition.status)).toEqual(["passed", "passed", "passed"]);
+    expect(evaluateTargetingGates(targeting, ctx)).toMatchInlineSnapshot(`
+      {
+        "gates": [
+          {
+            "detail": {
+              "pageRules": 0,
+              "rules": 1,
+              "url": "https://shop.test/products/shirt",
+            },
+            "id": "page",
+            "label": "Page check",
+            "reason": "url_matched",
+            "status": "passed",
+          },
+          {
+            "detail": {
+              "attributeRules": 1,
+              "segmentRules": 1,
+            },
+            "id": "audience",
+            "label": "Audience check",
+            "reason": "audience_matched",
+            "status": "passed",
+          },
+        ],
+        "matched": true,
+      }
+    `);
+  });
+});