Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

8.8 KB
Raw Blame
import { seedApiQueryCache } from "__support__/state";
import { createMockState } from "__support__/state/state";
import { createMockSdkState } from "embedding-sdk-bundle/test/mocks/state";
import type { EnterpriseSettings } from "metabase-types/api";
import {
  createMockSettings,
  createMockTokenFeatures,
} from "metabase-types/api/mocks";

const mockNewTracker = jest.fn();
const mockTrackSelfDescribingEvent = jest.fn();
const mockTrackMetaplowEvent = jest.fn();

jest.mock("@snowplow/browser-tracker", () => ({
  newTracker: (...args: unknown[]) => mockNewTracker(...args),
  trackSelfDescribingEvent: (...args: unknown[]) =>
    mockTrackSelfDescribingEvent(...args),
}));

jest.mock("metabase/utils/metaplow", () => ({
  trackMetaplowEvent: (...args: unknown[]) => mockTrackMetaplowEvent(...args),
}));

// Re-import the module under test so its module-scoped init guard resets per test.
const loadModule = () => import("./snowplow");

function makeStore(overrides: Partial<EnterpriseSettings> = {}) {
  // Seed the `getSessionProperties` RTK Query cache.
  const state = createMockState({ sdk: createMockSdkState() });
  const stateWithSettings = {
    ...state,
    "metabase-api": seedApiQueryCache(state["metabase-api"], [
      {
        endpointName: "getSessionProperties",
        value: createMockSettings({
          "anon-tracking-enabled": true,
          ...overrides,
        }),
      },
    ]),
  };
  return {
    getState: () => stateWithSettings,
  };
}

describe("embedding-sdk-bundle/analytics/snowplow (CSP transport)", () => {
  beforeEach(() => {
    jest.clearAllMocks();
    jest.resetModules();
  });

  describe("initSdkTracker", () => {
    // Assert only the flags whose absence fails silently in a customer's prod app:
    // proxy path (CSP), server anonymisation (privacy), and no host-page storage.
    // CORS: v4 sends credentials by default, so we omit them to satisfy wildcard CORS on the proxy.
    // Storage: v4 probes the root domain with a test cookie unless told not to.
    // The rest is cosmetic config, not a safety contract.
    it("configures the proxy path, anonymises, and touches no storage", async () => {
      const { initSdkTracker } = await loadModule();

      initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: false,
        store: makeStore(),
      });

      expect(mockNewTracker).toHaveBeenCalledTimes(1);
      // Only assert important config keys
      expect(mockNewTracker).toHaveBeenCalledWith(
        "sdk",
        "https://metabase.example.com",
        expect.objectContaining({
          postPath: "/api/analytics-proxy",
          stateStorageStrategy: "none",
          anonymousTracking: { withServerAnonymisation: true },
          discoverRootDomain: false,
          credentials: "omit",
        }),
      );
    });

    it("is idempotent — a second call does not create another tracker", async () => {
      const { initSdkTracker } = await loadModule();

      initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: false,
        store: makeStore(),
      });
      initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: false,
        store: makeStore(),
      });

      expect(mockNewTracker).toHaveBeenCalledTimes(1);
    });

    it("wasJustInitialized: true on first call, false on subsequent calls", async () => {
      const { initSdkTracker } = await loadModule();
      const store = makeStore();

      const firstResult = initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: false,
        store,
      });
      const secondResult = initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: false,
        store,
      });

      expect(firstResult).toBe(true);
      expect(secondResult).toBe(false);
    });

    it("attaches the instance context with analytics-uuid to every event", async () => {
      const { initSdkTracker } = await loadModule();

      initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: false,
        store: makeStore({
          "analytics-uuid": "test-uuid-123",
          version: { tag: "v0.50.0" },
          "instance-creation": "2024-01-01",
          "token-features": createMockTokenFeatures(),
        }),
      });

      const [, , config] = mockNewTracker.mock.lastCall!;
      const [plugin] = config.plugins;
      const contexts = plugin.contexts();

      expect(contexts).toContainEqual(
        expect.objectContaining({
          schema: "iglu:com.metabase/instance/jsonschema/1-1-0",
          data: expect.objectContaining({ id: "test-uuid-123" }),
        }),
      );
    });
  });

  describe("getSdkAuthMethod", () => {
    it("returns undefined before initSdkTracker is called", async () => {
      const { getSdkAuthMethod } = await loadModule();

      expect(getSdkAuthMethod()).toBeUndefined();
    });

    it("returns the auth method passed to initSdkTracker", async () => {
      const { initSdkTracker, getSdkAuthMethod } = await loadModule();

      initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "api_key",
        localeUsed: false,
        store: makeStore(),
      });

      expect(getSdkAuthMethod()).toBe("api_key");
    });
  });

  describe("getSdkLocaleUsed", () => {
    it("returns false before initSdkTracker is called", async () => {
      const { getSdkLocaleUsed } = await loadModule();

      expect(getSdkLocaleUsed()).toBe(false);
    });

    it("returns the locale_used flag passed to initSdkTracker", async () => {
      const { initSdkTracker, getSdkLocaleUsed } = await loadModule();

      initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: true,
        store: makeStore(),
      });

      expect(getSdkLocaleUsed()).toBe(true);
    });
  });

  describe("trackSdkSimpleEvent", () => {
    it("sends via SDK Snowplow proxy tracker with simple_event schema", async () => {
      const { trackSdkSimpleEvent } = await loadModule();

      trackSdkSimpleEvent({
        event: "embedding_sdk_initialized",
        event_detail: JSON.stringify({
          global: {
            auth_method: "sso",
            sdk_version: "1.0.0",
            locale_used: false,
          },
        }),
      });

      expect(mockTrackSelfDescribingEvent).toHaveBeenCalledWith(
        {
          event: {
            schema: "iglu:com.metabase/simple_event/jsonschema/1-0-0",
            data: {
              event: "embedding_sdk_initialized",
              event_detail: JSON.stringify({
                global: {
                  auth_method: "sso",
                  sdk_version: "1.0.0",
                  locale_used: false,
                },
              }),
            },
          },
        },
        ["sdk"],
      );
    });

    it("does not call Metaplow when the tracker has not been initialized", async () => {
      const { trackSdkSimpleEvent } = await loadModule();

      trackSdkSimpleEvent({
        event: "embedding_sdk_initialized",
        event_detail: "",
      });

      expect(mockTrackMetaplowEvent).not.toHaveBeenCalled();
    });

    it("does not call Metaplow when metaplow-tracking-enabled is false", async () => {
      const { initSdkTracker, trackSdkSimpleEvent } = await loadModule();

      initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: false,
        store: makeStore({ "metaplow-tracking-enabled": false }),
      });

      trackSdkSimpleEvent({
        event: "embedding_sdk_initialized",
        event_detail: "",
      });

      expect(mockTrackMetaplowEvent).not.toHaveBeenCalled();
    });

    it("calls Metaplow when metaplow-tracking-enabled is on", async () => {
      const { initSdkTracker, trackSdkSimpleEvent } = await loadModule();

      initSdkTracker({
        metabaseInstanceUrl: "https://metabase.example.com",
        authMethod: "sso",
        localeUsed: false,
        store: makeStore({ "metaplow-tracking-enabled": true }),
      });

      trackSdkSimpleEvent({
        event: "embedding_sdk_initialized",
        event_detail: JSON.stringify({
          global: {
            auth_method: "sso",
            sdk_version: "1.0.0",
            locale_used: false,
          },
        }),
      });

      expect(mockTrackMetaplowEvent).toHaveBeenCalledWith(
        "embedding_sdk_initialized",
        {
          event_detail: JSON.stringify({
            global: {
              auth_method: "sso",
              sdk_version: "1.0.0",
              locale_used: false,
            },
          }),
        },
      );
    });
  });
});