@drip-apex/sdk 0.1.0 → 0.2.0

package/src/init-qa-loading.test.ts

@@ -0,0 +1,740 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  RECENT_MONDAY_NOON, documentListeners, windowListeners, appendedAntiFlickerStyle, configPayloadHash, flushDynamicImports, installCookieJar, installMutationObserverStub, makeClassList, makeStorage, readCookieValue, readDecodedDripContext, registerInitTestLifecycle, verifiedHandoverResponse,
+} from "./init-test-helpers";
+
+describe("init qa loading", () => {
+  registerInitTestLifecycle();
+
+
+  it.each(["?drip_qa=1", "?drip_screenshot=1"])(
+    "keeps forced operational assignments out of the holdout gate for %s",
+    async (search) => {
+      (globalThis as any).location.search = `${search}&drip_force=exp_operational:var_operational`;
+      const { init, getAssignments } = await import("./index");
+      const { isHoldoutVisitor } = await import("./hash");
+      const userId = Array.from({ length: 1000 }, (_, index) => `operational-${index}`).find((id) =>
+        isHoldoutVisitor({ holdout_v1_enabled: true, holdout_pct: 10 }, id),
+      );
+      expect(userId).toBeTruthy();
+
+      init({
+        antiFlickerMode: "off",
+        endpoint: "https://events.test",
+        experiments: [{
+          id: "exp_operational",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [{ id: "var_operational", weight: 1, mutations: [] }],
+        }],
+        holdout_v1_enabled: true,
+        holdout_pct: 10,
+        shopId: "shop_123",
+        trackingStart: "immediate",
+        userId: userId!,
+      });
+
+      expect(getAssignments()).toEqual([
+        expect.objectContaining({ experimentId: "exp_operational", variationId: "var_operational" }),
+      ]);
+    },
+  );
+
+
+  it("exposes installed-site diagnostics for QA automation", async () => {
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      dataProtection: {
+        respectDoNotTrack: true,
+        storageMode: "localStorage",
+      },
+      debug: {
+        enabled: true,
+        restrictMode: "always",
+      },
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_123",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "var_123",
+              weight: 1,
+              mutations: [],
+            },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(getDiagnostics()).toMatchObject({
+      mode: "debug",
+      initialized: true,
+      shopId: "shop_123",
+      experimentsLoaded: 1,
+      analyticsStarted: true,
+      trackerStarted: true,
+      configSource: "inline",
+      platform: "auto",
+      routerMode: "history",
+      activationMode: "observer",
+      consentRequired: false,
+      consentGranted: true,
+      storage: {
+        mode: "localStorage",
+        localStorageAvailable: true,
+        sessionStorageAvailable: true,
+        cookiesEnabled: true,
+      },
+      runtime: {
+        antiFlickerMode: "off",
+        trackingStart: "immediate",
+        pageTriggerMode: "direct",
+      },
+    });
+    expect(getDiagnostics().assignments).toHaveLength(1);
+    expect(getDiagnostics().assignments[0]).toMatchObject({
+      experimentId: "exp_123",
+      variationId: "var_123",
+      mutationCount: 0,
+    });
+    expect(getDiagnostics().activation.experiments[0]).toMatchObject({
+      experimentId: "exp_123",
+      status: "passed",
+      assignedVariationId: "var_123",
+    });
+  });
+
+
+  it("reports an unmatched precompiled campaign in activation diagnostics", async () => {
+    const { getDiagnostics, init } = await import("./index");
+
+    const assignments = init({
+      antiFlickerMode: "off",
+      delivery: {
+        criticalMutationPlan: [{
+          e: "exp_precompiled_url",
+          r: [{ type: "simple", pattern: "/products/*" }],
+          v: [{ id: "var_precompiled_url", w: 1, m: [] }],
+        }],
+      },
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_precompiled_url",
+        name: "Precompiled URL campaign",
+        status: "running",
+        targeting: { url: [{ type: "simple", pattern: "/products/*" }] },
+        trafficAllocation: 1,
+        variations: [{ id: "var_precompiled_url", weight: 1, mutations: [] }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_precompiled_url",
+    });
+
+    expect(assignments).toHaveLength(0);
+    expect(getDiagnostics().activation.experiments).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_precompiled_url",
+        status: "failed",
+        reason: "url_mismatch",
+        gates: expect.arrayContaining([
+          expect.objectContaining({
+            id: "page",
+            status: "failed",
+            reason: "url_mismatch",
+          }),
+          expect.objectContaining({
+            id: "audience",
+            status: "skipped",
+            reason: "page_mismatch",
+          }),
+        ]),
+      }),
+    ]);
+  });
+
+
+  it("reports a precompiled campaign outside its traffic allocation", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "",
+    };
+    const { getDiagnostics, init } = await import("./index");
+
+    const assignments = init({
+      antiFlickerMode: "off",
+      delivery: {
+        criticalMutationPlan: [{
+          e: "exp_precompiled_allocation",
+          r: [{ type: "simple", pattern: "/products/*" }],
+          v: [{ id: "var_precompiled_allocation", w: 1, m: [] }],
+        }],
+      },
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_precompiled_allocation",
+        name: "Precompiled allocation campaign",
+        status: "running",
+        targeting: { url: [{ type: "simple", pattern: "/products/*" }] },
+        trafficAllocation: 0,
+        variations: [{ id: "var_precompiled_allocation", weight: 1, mutations: [] }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_precompiled_allocation",
+    });
+
+    expect(assignments).toHaveLength(0);
+    expect(getDiagnostics().activation.experiments).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_precompiled_allocation",
+        status: "failed",
+        reason: "outside_allocation",
+        gates: expect.arrayContaining([
+          expect.objectContaining({ id: "page", status: "passed" }),
+          expect.objectContaining({
+            id: "audience",
+            status: "skipped",
+            reason: "no_audience_rules",
+          }),
+          expect.objectContaining({
+            id: "traffic",
+            status: "failed",
+            reason: "outside_allocation",
+          }),
+        ]),
+      }),
+    ]);
+  });
+
+
+  it("preserves successful precompiled assignment diagnostics", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "",
+    };
+    const { getDiagnostics, init } = await import("./index");
+
+    const assignments = init({
+      antiFlickerMode: "off",
+      delivery: {
+        criticalMutationPlan: [{
+          e: "exp_precompiled_success",
+          r: [{ type: "simple", pattern: "/products/*" }],
+          v: [{ id: "var_precompiled_success", w: 1, m: [] }],
+        }],
+      },
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_precompiled_success",
+        name: "Precompiled success campaign",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{ id: "var_precompiled_success", weight: 1, mutations: [], artifactSource: "operator_chat" }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_precompiled_success",
+    });
+
+    expect(assignments).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_precompiled_success",
+        variationId: "var_precompiled_success",
+        artifactSource: "operator_chat",
+      }),
+    ]);
+    expect(getDiagnostics().activation.experiments).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_precompiled_success",
+        status: "passed",
+        reason: "precompiled_assignment",
+        assignedVariationId: "var_precompiled_success",
+        gates: [
+          expect.objectContaining({ id: "page", status: "passed" }),
+          expect.objectContaining({ id: "audience", status: "skipped", reason: "no_audience_rules" }),
+          expect.objectContaining({ id: "traffic", status: "passed" }),
+          expect.objectContaining({ id: "assignment", status: "passed" }),
+        ],
+      }),
+    ]);
+  });
+
+
+  it("exposes page targeting failures in activation diagnostics", async () => {
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_page",
+          status: "running",
+          targeting: {
+            url: [{ type: "simple", pattern: "/products/*" }],
+          },
+          trafficAllocation: 1,
+          variations: [{ id: "var_page", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    const experiment = getDiagnostics().activation.experiments[0];
+    expect(experiment).toMatchObject({
+      experimentId: "exp_page",
+      status: "failed",
+      reason: "url_mismatch",
+    });
+    expect(experiment.gates.find((gate) => gate.id === "page")).toMatchObject({
+      status: "failed",
+      reason: "url_mismatch",
+    });
+  });
+
+
+  it("keeps forced QA assignments off-target while preserving page targeting diagnostics", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/collections/all?drip_qa=1&drip_force=exp_forced:var_forced",
+      origin: "https://plain.test",
+      pathname: "/collections/all",
+      search: "?drip_qa=1&drip_force=exp_forced:var_forced",
+    };
+
+    const { __test, getDiagnostics, init } = await import("./index");
+
+    const assignments = init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_forced",
+          status: "draft",
+          targeting: {
+            url: [{ type: "simple", pattern: "/products/target-product" }],
+          },
+          trafficAllocation: 1,
+          variations: [
+            { id: "var_control", weight: 0.5, mutations: [] },
+            { id: "var_forced", weight: 0.5, mutations: [{ selector: "h1", action: "text", text: "Forced" }] },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(assignments).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_forced",
+        variationId: "var_forced",
+        pageActive: false,
+      }),
+    ]);
+    expect(__test!.artifactRenderableAssignments(assignments)).toEqual([]);
+    const experiment = getDiagnostics().activation.experiments[0];
+    expect(experiment).toMatchObject({
+      experimentId: "exp_forced",
+      status: "passed",
+      reason: "forced_variation",
+      forced: true,
+    });
+    expect(experiment.gates.find((gate) => gate.id === "environment")).toMatchObject({
+      status: "skipped",
+      reason: "forced_variation",
+    });
+    expect(experiment.gates.find((gate) => gate.id === "page")).toMatchObject({
+      status: "failed",
+      reason: "url_mismatch",
+    });
+  });
+
+
+  it("does not let forced QA assignment bypass audience targeting", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1&drip_force=exp_audience:var_audience",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1&drip_force=exp_audience:var_audience",
+    };
+    const { getDiagnostics, init } = await import("./index");
+    const assignments = init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_audience",
+        status: "draft",
+        targeting: {
+          segmentRules: [{
+            id: "vip",
+            rules: {
+              version: 1,
+              operator: "and",
+              conditions: [{ signal: "customer.tier", operator: "equals", value: "vip" }],
+            },
+          }],
+        },
+        trafficAllocation: 1,
+        variations: [{ id: "var_audience", weight: 1, mutations: [] }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    expect(assignments).toHaveLength(0);
+    expect(getDiagnostics().activation.experiments[0]).toMatchObject({
+      experimentId: "exp_audience",
+      status: "failed",
+      reason: "segment_mismatch",
+      forced: false,
+    });
+  });
+
+
+  it.each([
+    [
+      "desktop",
+      "Win32",
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
+    ],
+    [
+      "mobile",
+      "iPhone",
+      "Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X) AppleWebKit/605.1.15 Mobile/15E148 Safari/604.1",
+    ],
+    [
+      "tablet",
+      "Linux armv8l",
+      "Mozilla/5.0 (Linux; Android 13; Pixel C) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
+    ],
+  ])("applies a forced QA variation for a matching %s device audience", async (token, platform, userAgent) => {
+    Object.defineProperty(globalThis, "navigator", {
+      configurable: true,
+      value: { userAgent, platform, doNotTrack: "0" },
+    });
+    (globalThis as any).window.innerWidth = 1280;
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1&drip_force=exp_device:var_device",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1&drip_force=exp_device:var_device",
+    };
+    const { getDiagnostics, init } = await import("./index");
+    const assignments = init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_device",
+        status: "draft",
+        targeting: {
+          segmentRules: [{
+            id: "device-audience",
+            rules: {
+              version: 1,
+              operator: "and",
+              conditions: [{ signal: "device.type", operator: "equals", value: token }],
+            },
+          }],
+        },
+        trafficAllocation: 1,
+        variations: [{ id: "var_device", weight: 1, mutations: [] }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(assignments).toEqual([
+      expect.objectContaining({ experimentId: "exp_device", variationId: "var_device" }),
+    ]);
+    expect(getDiagnostics().activation.experiments[0]).toMatchObject({
+      experimentId: "exp_device",
+      status: "passed",
+      forced: true,
+    });
+  });
+
+
+  it("blocks a forced QA variation when the detected device does not match", async () => {
+    Object.defineProperty(globalThis, "navigator", {
+      configurable: true,
+      value: {
+        userAgent:
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
+        platform: "Win32",
+        doNotTrack: "0",
+      },
+    });
+    (globalThis as any).window.innerWidth = 390;
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1&drip_force=exp_device_mismatch:var_device",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1&drip_force=exp_device_mismatch:var_device",
+    };
+    const { getDiagnostics, init } = await import("./index");
+    const assignments = init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_device_mismatch",
+        status: "draft",
+        targeting: {
+          segmentRules: [{
+            id: "mobile-audience",
+            rules: {
+              version: 1,
+              operator: "and",
+              conditions: [{ signal: "device.type", operator: "equals", value: "mobile" }],
+            },
+          }],
+        },
+        trafficAllocation: 1,
+        variations: [{ id: "var_device", weight: 1, mutations: [] }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(assignments).toHaveLength(0);
+    const experiment = getDiagnostics().activation.experiments[0];
+    expect(experiment).toMatchObject({
+      experimentId: "exp_device_mismatch",
+      status: "failed",
+      reason: "segment_mismatch",
+      forced: false,
+    });
+    expect(experiment.gates.find((gate) => gate.id === "audience")).toMatchObject({
+      status: "failed",
+      reason: "segment_mismatch",
+    });
+    expect(experiment.targetingConditions).toContainEqual(expect.objectContaining({
+      signal: "device.type",
+      expected: "mobile",
+      actual: "desktop",
+    }));
+  });
+
+
+  it("does not persist forced QA assignments over sticky assignment storage", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1&drip_force=exp_forced:var_forced",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1&drip_force=exp_forced:var_forced",
+    };
+    localStorage.setItem(
+      "drip_assignments_v1",
+      JSON.stringify({ exp_forced: ["var_control", 1, 123] }),
+    );
+
+    const { init } = await import("./index");
+
+    const assignments = init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_forced",
+          status: "draft",
+          targeting: {
+            url: [{ type: "simple", pattern: "/products/a" }],
+          },
+          trafficAllocation: 1,
+          assignmentEpoch: 1,
+          variations: [
+            { id: "var_control", weight: 1, mutations: [] },
+            { id: "var_forced", weight: 0, mutations: [] },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(assignments[0]?.variationId).toBe("var_forced");
+    expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}")).toEqual({
+      exp_forced: ["var_control", 1, 123],
+    });
+  });
+
+
+  it("applies forced control mutations, CSS, and JS in QA preview", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1&drip_force=exp_control:var_control",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1&drip_force=exp_control:var_control",
+    };
+    const title = { textContent: "Original headline" };
+    const styles: Array<Record<string, any>> = [];
+    (globalThis as any).document.createElement = vi.fn((tag: string) => ({
+      id: "",
+      className: "",
+      remove: vi.fn(),
+      tagName: tag.toUpperCase(),
+      textContent: "",
+    }));
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#control-title" ? [title] : []
+    ));
+    (globalThis as any).document.getElementById = vi.fn((id: string) => (
+      styles.find((element) => element.id === id) ?? null
+    ));
+    (globalThis as any).document.head.appendChild = vi.fn((element: Record<string, any>) => {
+      styles.push(element);
+      return element;
+    });
+
+    const { init } = await import("./index");
+
+    const assignments = init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_control",
+          status: "draft",
+          targeting: { url: [{ type: "simple", pattern: "/products/a" }] },
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "var_control",
+              weight: 0,
+              isControl: true,
+              mutations: [{ selector: "#control-title", action: "text", text: "Prepared control headline" }],
+              css: "#control-title{display:block}",
+              js: "window.__forcedControlJs=true;",
+            },
+            { id: "var_treatment", weight: 1, mutations: [] },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      spa: { activationMode: "manual" },
+      trackingStart: "immediate",
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(assignments[0]).toMatchObject({ variationId: "var_control", isControl: true });
+    expect(title.textContent).toBe("Prepared control headline");
+    expect((globalThis as any).window.__forcedControlJs).toBe(true);
+    expect(styles.find((style) => style.id === "drip-css-exp_control-var_control")?.textContent)
+      .toBe("#control-title{display:block}");
+  });
+
+
+  it("does not mount legacy devtools alongside QA Assistant in QA mode", async () => {
+    (globalThis as any).location.search = "?drip_qa=1&drip_debug=1";
+    (globalThis as any).location.href = "https://plain.test/?drip_qa=1&drip_debug=1";
+    const mountQaAssistant = vi.fn(() => ({ destroy: vi.fn() }));
+    const mountDevtools = vi.fn();
+    vi.doMock("./qa-assistant", () => ({ mountQaAssistant }));
+    vi.doMock("./devtools", () => ({
+      isDevtoolsEnabled: vi.fn(() => true),
+      logDevtoolsEvent: vi.fn(),
+      mountDevtools,
+      unmountDevtools: vi.fn(),
+    }));
+
+    const { init } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await flushDynamicImports();
+
+    expect(mountQaAssistant).toHaveBeenCalledTimes(1);
+    expect(mountDevtools).not.toHaveBeenCalled();
+  });
+
+
+  it("falls back to the legacy QA toolbar and devtools when QA Assistant is unavailable", async () => {
+    (globalThis as any).location.search = "?drip_qa=1&drip_debug=1";
+    (globalThis as any).location.href = "https://plain.test/?drip_qa=1&drip_debug=1";
+    const mountQaAssistant = vi.fn(() => null);
+    const mountQaToolbar = vi.fn();
+    const mountDevtools = vi.fn();
+    vi.doMock("./qa-assistant", () => ({ mountQaAssistant }));
+    vi.doMock("./qa-toolbar", () => ({ mountQaToolbar }));
+    vi.doMock("./devtools", () => ({
+      isDevtoolsEnabled: vi.fn(() => true),
+      logDevtoolsEvent: vi.fn(),
+      mountDevtools,
+      unmountDevtools: vi.fn(),
+    }));
+
+    const { init } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await flushDynamicImports();
+
+    expect(mountQaAssistant).toHaveBeenCalledTimes(1);
+    expect(mountQaToolbar).toHaveBeenCalledTimes(1);
+    expect(mountDevtools).toHaveBeenCalledTimes(1);
+  });
+
+
+  it("still mounts legacy devtools outside QA mode when explicitly requested", async () => {
+    (globalThis as any).location.search = "?drip_devtools=1";
+    (globalThis as any).location.href = "https://plain.test/?drip_devtools=1";
+    const mountQaAssistant = vi.fn(() => ({ destroy: vi.fn() }));
+    const mountDevtools = vi.fn();
+    vi.doMock("./qa-assistant", () => ({ mountQaAssistant }));
+    vi.doMock("./devtools", () => ({
+      isDevtoolsEnabled: vi.fn(() => true),
+      logDevtoolsEvent: vi.fn(),
+      mountDevtools,
+      unmountDevtools: vi.fn(),
+    }));
+
+    const { init } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await flushDynamicImports();
+
+    expect(mountQaAssistant).not.toHaveBeenCalled();
+    expect(mountDevtools).toHaveBeenCalledTimes(1);
+  });
+});