mixpanel-react-native 3.0.9 → 3.1.0

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/__mocks__/@react-native-async-storage/async-storage.js

@@ -0,0 +1 @@
+export * from "@react-native-async-storage/async-storage/jest/async-storage-mock";

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/__tests__/core.test.js

@@ -0,0 +1,135 @@
+import { MixpanelType } from "mixpanel-react-native/javascript/mixpanel-constants";
+
+jest.mock("mixpanel-react-native/javascript/mixpanel-queue", () => ({
+  MixpanelQueueManager: {
+    initialize: jest.fn(),
+    enqueue: jest.fn(),
+    getQueue: jest.fn(),
+    spliceQueue: jest.fn(),
+    clearQueue: jest.fn(),
+  },
+}));
+
+jest.mock("mixpanel-react-native/javascript/mixpanel-persistent", () => ({
+  MixpanelPersistent: {
+    getInstance: jest.fn().mockReturnValue({
+      getOptedOut: jest.fn(),
+    }),
+  },
+}));
+
+jest.mock("mixpanel-react-native/javascript/mixpanel-network", () => ({
+  MixpanelNetwork: {
+    sendRequest: jest.fn(),
+  },
+}));
+
+jest.mock("mixpanel-react-native/javascript/mixpanel-config", () => ({
+  MixpanelConfig: {
+    getInstance: jest.fn().mockReturnValue({
+      getFlushInterval: jest.fn().mockReturnValue(1000),
+      getFlushBatchSize: jest.fn().mockReturnValue(50),
+      getServerURL: jest.fn(),
+      getUseIpAddressForGeolocation: jest.fn(),
+    }),
+  },
+}));
+
+jest.mock("mixpanel-react-native/javascript/mixpanel-logger", () => ({
+  MixpanelLogger: {
+    log: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const {
+  MixpanelCore,
+} = require("mixpanel-react-native/javascript/mixpanel-core");
+
+const {
+  MixpanelQueueManager,
+} = require("mixpanel-react-native/javascript/mixpanel-queue");
+
+const {
+  MixpanelPersistent,
+} = require("mixpanel-react-native/javascript/mixpanel-persistent");
+
+const {
+  MixpanelNetwork,
+} = require("mixpanel-react-native/javascript/mixpanel-network");
+
+describe("MixpanelQueueManager", () => {
+  let mixpanelPersistent;
+  const token = "test-token";
+  const type = MixpanelType.EVENTS;
+  const data = { event: "testEvent" };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.isolateModules(() => {
+      MixpanelPersistent.getInstance().getOptedOut.mockReturnValue(false);
+      MixpanelQueueManager.getQueue.mockReturnValue([]);
+    });
+  });
+
+  it("initializes the Mixpanel queue for events", async () => {
+    await MixpanelCore().initialize(token);
+    expect(MixpanelQueueManager.initialize).toHaveBeenCalledWith(
+      token,
+      expect.any(String)
+    );
+  });
+
+  it("adds data to the Mixpanel queue if not opted out and data is valid", async () => {
+    MixpanelPersistent.getInstance().getOptedOut.mockReturnValueOnce(false);
+    await MixpanelCore().addToMixpanelQueue(token, type, data);
+    expect(MixpanelQueueManager.enqueue).toHaveBeenCalledWith(
+      token,
+      type,
+      expect.any(Object)
+    );
+  });
+
+  it("do not add data to the Mixpanel queue if opted out", async () => {
+    MixpanelPersistent.getInstance().getOptedOut.mockReturnValueOnce(true);
+    await MixpanelCore().addToMixpanelQueue(token, type, data);
+    expect(MixpanelQueueManager.enqueue).toHaveBeenCalledTimes(0);
+  });
+
+  it("do not add data to the Mixpanel queue if data is not valid", async () => {
+    MixpanelPersistent.getInstance().getOptedOut.mockReturnValueOnce(false);
+    // mock JSON.stringify to throw an error
+    jest.spyOn(JSON, "stringify").mockImplementationOnce(() => {
+      throw new Error("mock error");
+    });
+    await MixpanelCore().addToMixpanelQueue(token, type, data);
+    expect(MixpanelQueueManager.enqueue).toHaveBeenCalledTimes(0);
+  });
+
+  it("flushes the queue", async () => {
+    MixpanelPersistent.getInstance().getOptedOut.mockReturnValueOnce(false);
+    MixpanelQueueManager.getQueue.mockImplementation((token, type) => {
+      return [data];
+    });
+    await MixpanelCore().flush(token);
+    expect(MixpanelNetwork.sendRequest).toHaveBeenCalled();
+  });
+
+  it("do not flush the queue if opted out", async () => {
+    MixpanelPersistent.getInstance().getOptedOut.mockReturnValueOnce(true);
+    MixpanelQueueManager.getQueue.mockImplementation((token, type) => {
+      return [data];
+    });
+    await MixpanelCore().flush(token);
+    expect(MixpanelNetwork.sendRequest).toHaveBeenCalledTimes(0);
+  });
+
+  it("not flushes the queue if there is no data", async () => {
+    MixpanelPersistent.getInstance().getOptedOut.mockReturnValueOnce(false);
+    MixpanelQueueManager.getQueue.mockImplementation((token, type) => {
+      return [];
+    });
+    await MixpanelCore().flush(token);
+    expect(MixpanelNetwork.sendRequest).toHaveBeenCalledTimes(0);
+  });
+});

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/__tests__/index.test.js

@@ -0,0 +1,449 @@
+import {Mixpanel} from "mixpanel-react-native";
+import {NativeModules} from "react-native";
+
+test(`it calls MixpanelReactNative initialize`, async () => {
+  const mixpanel = await Mixpanel.init("token", true);
+  expect(NativeModules.MixpanelReactNative.initialize).toBeCalledWith(
+    "token",
+    true,
+    false,
+    {$lib_version: expect.any(String), mp_lib: "react-native"},
+    "https://api.mixpanel.com"
+  );
+});
+
+test(`it calls MixpanelReactNative initialize with optOut and superProperties`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init(true, {super: "property"});
+  expect(NativeModules.MixpanelReactNative.initialize).toBeCalledWith(
+    "token",
+    true,
+    true,
+    {
+      $lib_version: expect.any(String),
+      mp_lib: "react-native",
+      super: "property",
+    },
+    "https://api.mixpanel.com"
+  );
+});
+
+test(`it calls MixpanelReactNative setServerURL`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.setServerURL("https://api-eu.mixpanel.com");
+  expect(NativeModules.MixpanelReactNative.setServerURL).toBeCalledWith(
+    "token",
+    "https://api-eu.mixpanel.com"
+  );
+});
+
+test(`it calls MixpanelReactNative setLoggingEnabled`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.setLoggingEnabled(true);
+  expect(NativeModules.MixpanelReactNative.setLoggingEnabled).toBeCalledWith(
+    "token",
+    true
+  );
+});
+
+test(`it calls MixpanelReactNative setUseIpAddressForGeolocation`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.setUseIpAddressForGeolocation(true);
+  expect(
+    NativeModules.MixpanelReactNative.setUseIpAddressForGeolocation
+  ).toBeCalledWith("token", true);
+});
+
+test(`it calls MixpanelReactNative setFlushBatchSize`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.setFlushBatchSize(20);
+  expect(NativeModules.MixpanelReactNative.setFlushBatchSize).toBeCalledWith(
+    "token",
+    20
+  );
+});
+
+test(`it calls MixpanelReactNative hasOptedOutTracking`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.hasOptedOutTracking();
+  expect(NativeModules.MixpanelReactNative.hasOptedOutTracking).toBeCalledWith(
+    "token"
+  );
+});
+
+test(`it calls MixpanelReactNative optInTracking`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.optInTracking();
+  expect(NativeModules.MixpanelReactNative.optInTracking).toBeCalledWith(
+    "token"
+  );
+});
+
+test(`it calls MixpanelReactNative optOutTracking`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.optOutTracking();
+  expect(NativeModules.MixpanelReactNative.optOutTracking).toBeCalledWith(
+    "token"
+  );
+});
+
+test(`it calls MixpanelReactNative identify`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.identify("distinct_id");
+  expect(NativeModules.MixpanelReactNative.identify).toBeCalledWith(
+    "token",
+    "distinct_id"
+  );
+});
+
+test(`it calls MixpanelReactNative alias`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.alias("alias", "distinct_id");
+  expect(NativeModules.MixpanelReactNative.alias).toBeCalledWith(
+    "token",
+    "alias",
+    "distinct_id"
+  );
+});
+
+test(`it calls MixpanelReactNative track`, async () => {
+  const mixpanel = await Mixpanel.init("token", true);
+  mixpanel.track("event name", {
+    "Cool Property": "Property Value",
+  });
+  expect(NativeModules.MixpanelReactNative.track).toBeCalledWith(
+    "token",
+    "event name",
+    {
+      "Cool Property": "Property Value",
+      $lib_version: expect.any(String),
+      mp_lib: "react-native",
+    }
+  );
+});
+
+test(`it calls MixpanelReactNative trackWithGroups`, async () => {
+  const mixpanel = await Mixpanel.init("token", true);
+  mixpanel.trackWithGroups(
+    "tracked with groups",
+    {a: 1, b: 2.3},
+    {company_id: "Mixpanel"}
+  );
+  expect(NativeModules.MixpanelReactNative.trackWithGroups).toBeCalledWith(
+    "token",
+    "tracked with groups",
+    {a: 1, b: 2.3, $lib_version: expect.any(String), mp_lib: "react-native"},
+    {company_id: "Mixpanel"}
+  );
+});
+
+test(`it calls MixpanelReactNative setGroup`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.setGroup("company_id", 12345);
+  expect(NativeModules.MixpanelReactNative.setGroup).toBeCalledWith(
+    "token",
+    "company_id",
+    12345
+  );
+});
+
+test(`it calls MixpanelReactNative addGroup`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.addGroup("company_id", 12345);
+  expect(NativeModules.MixpanelReactNative.addGroup).toBeCalledWith(
+    "token",
+    "company_id",
+    12345
+  );
+});
+
+test(`it calls MixpanelReactNative removeGroup`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.removeGroup("company_id", 12345);
+  expect(NativeModules.MixpanelReactNative.removeGroup).toBeCalledWith(
+    "token",
+    "company_id",
+    12345
+  );
+});
+
+test(`it calls MixpanelReactNative deleteGroup`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.deleteGroup("company_id", 12345);
+  expect(NativeModules.MixpanelReactNative.deleteGroup).toBeCalledWith(
+    "token",
+    "company_id",
+    12345
+  );
+});
+
+test(`it calls MixpanelReactNative registerSuperProperties`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.registerSuperProperties({
+    "super property": "super property value",
+    "super property1": "super property value1",
+  });
+  expect(
+    NativeModules.MixpanelReactNative.registerSuperProperties
+  ).toBeCalledWith("token", {
+    "super property": "super property value",
+    "super property1": "super property value1",
+  });
+});
+
+test(`it calls MixpanelReactNative registerSuperPropertiesOnce`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.registerSuperPropertiesOnce({
+    "super property": "super property value",
+    "super property1": "super property value1",
+  });
+  expect(
+    NativeModules.MixpanelReactNative.registerSuperProperties
+  ).toBeCalledWith("token", {
+    "super property": "super property value",
+    "super property1": "super property value1",
+  });
+});
+
+test(`it calls MixpanelReactNative unregisterSuperProperty`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.unregisterSuperProperty("super property");
+  expect(
+    NativeModules.MixpanelReactNative.unregisterSuperProperty
+  ).toBeCalledWith("token", "super property");
+});
+
+test(`it calls MixpanelReactNative getSuperProperties`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getSuperProperties();
+  expect(NativeModules.MixpanelReactNative.getSuperProperties).toBeCalledWith(
+    "token"
+  );
+});
+
+test(`it calls MixpanelReactNative clearSuperProperties`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.clearSuperProperties();
+  expect(NativeModules.MixpanelReactNative.clearSuperProperties).toBeCalledWith(
+    "token"
+  );
+});
+
+test(`it calls MixpanelReactNative timeEvent`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.timeEvent("Timed Event");
+  expect(NativeModules.MixpanelReactNative.timeEvent).toBeCalledWith(
+    "token",
+    "Timed Event"
+  );
+});
+
+test(`it calls MixpanelReactNative eventElapsedTime`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.eventElapsedTime("Timed Event");
+  expect(NativeModules.MixpanelReactNative.eventElapsedTime).toBeCalledWith(
+    "token",
+    "Timed Event"
+  );
+});
+
+test(`it calls MixpanelReactNative reset`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.reset();
+  expect(NativeModules.MixpanelReactNative.reset).toBeCalledWith("token");
+});
+
+test(`it calls MixpanelReactNative getDistinctId`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getDistinctId();
+  expect(NativeModules.MixpanelReactNative.getDistinctId).toBeCalledWith(
+    "token"
+  );
+});
+
+test(`it calls MixpanelReactNative profile set`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().set({
+    a: 1,
+    b: 2.3,
+    c: ["4", 5],
+  });
+  expect(NativeModules.MixpanelReactNative.set).toBeCalledWith("token", {
+    a: 1,
+    b: 2.3,
+    c: ["4", 5],
+  });
+  // set one property
+  mixpanel.getPeople().set("a", 1);
+  expect(NativeModules.MixpanelReactNative.set).toBeCalledWith("token", {a: 1});
+});
+
+test(`it calls MixpanelReactNative profile setOnce`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().setOnce({
+    a: 1,
+    b: 2.3,
+    c: ["4", 5],
+  });
+  expect(NativeModules.MixpanelReactNative.setOnce).toBeCalledWith("token", {
+    a: 1,
+    b: 2.3,
+    c: ["4", 5],
+  });
+  // set one property
+  mixpanel.getPeople().setOnce("a", 1);
+  expect(NativeModules.MixpanelReactNative.setOnce).toBeCalledWith("token", {
+    a: 1,
+  });
+});
+
+test(`it calls MixpanelReactNative profile increment`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().increment({
+    a: 1,
+    b: 2.3,
+  });
+  expect(NativeModules.MixpanelReactNative.increment).toBeCalledWith("token", {
+    a: 1,
+    b: 2.3,
+  });
+  // set one property
+  mixpanel.getPeople().increment("a", 1);
+  expect(NativeModules.MixpanelReactNative.increment).toBeCalledWith("token", {
+    a: 1,
+  });
+});
+
+test(`it calls MixpanelReactNative profile append`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().append("a", "1");
+  expect(NativeModules.MixpanelReactNative.append).toBeCalledWith("token", {
+    a: "1",
+  });
+});
+
+test(`it calls MixpanelReactNative profile union`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().union("a1", "1");
+  expect(NativeModules.MixpanelReactNative.union).toBeCalledWith("token", {
+    a1: ["1"],
+  });
+});
+
+test(`it calls MixpanelReactNative profile remove`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().remove("a", "1");
+  expect(NativeModules.MixpanelReactNative.remove).toBeCalledWith("token", {
+    a: "1",
+  });
+});
+
+test(`it calls MixpanelReactNative profile unset`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().unset("a");
+  expect(NativeModules.MixpanelReactNative.unset).toBeCalledWith("token", "a");
+});
+
+test(`it calls MixpanelReactNative profile trackCharge`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().trackCharge(22.8);
+  expect(NativeModules.MixpanelReactNative.trackCharge).toBeCalledWith(
+    "token",
+    22.8,
+    {}
+  );
+});
+
+test(`it calls MixpanelReactNative profile clearCharges`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().clearCharges();
+  expect(NativeModules.MixpanelReactNative.clearCharges).toBeCalledWith(
+    "token"
+  );
+});
+
+test(`it calls MixpanelReactNative profile deleteUser`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getPeople().deleteUser();
+  expect(NativeModules.MixpanelReactNative.deleteUser).toBeCalledWith("token");
+});
+
+test(`it calls MixpanelReactNative group set properties`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getGroup("company_id", 12345).set("prop_key", "prop_value");
+  expect(
+    NativeModules.MixpanelReactNative.groupSetProperties
+  ).toBeCalledWith("token", "company_id", 12345, {prop_key: "prop_value"});
+});
+
+test(`it calls MixpanelReactNative group set property once`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getGroup("company_id", 12345).setOnce("prop_key", "prop_value");
+  expect(
+    NativeModules.MixpanelReactNative.groupSetPropertyOnce
+  ).toBeCalledWith("token", "company_id", 12345, {prop_key: "prop_value"});
+});
+
+test(`it calls MixpanelReactNative group unset property`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getGroup("company_id", 12345).unset("prop_key");
+  expect(NativeModules.MixpanelReactNative.groupUnsetProperty).toBeCalledWith(
+    "token",
+    "company_id",
+    12345,
+    "prop_key"
+  );
+});
+
+test(`it calls MixpanelReactNative group remove property`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getGroup("company_id", 12345).remove("prop_key", "334");
+  expect(
+    NativeModules.MixpanelReactNative.groupRemovePropertyValue
+  ).toBeCalledWith("token", "company_id", 12345, "prop_key", "334");
+});
+
+test(`it calls MixpanelReactNative group union property`, async () => {
+  const mixpanel = new Mixpanel("token", true);
+  mixpanel.init();
+  mixpanel.getGroup("company_id", 12345).union("prop_key", "334");
+  expect(
+    NativeModules.MixpanelReactNative.groupRemovePropertyValue
+  ).toBeCalledWith("token", "company_id", 12345, "prop_key", "334");
+});

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/__tests__/jest_setup.js

@@ -0,0 +1,93 @@
+import * as ReactNative from "react-native";
+import { jest } from "@jest/globals";
+
+jest.mock("expo-crypto", () => ({
+  randomUUID: jest.fn(
+    () => "mocked-uuid-string-" + Math.random().toString(36).substring(2, 15)
+  ), // Provides a somewhat unique mock UUID
+}));
+
+jest.mock("mixpanel-react-native/javascript/mixpanel-storage", () => {
+  return {
+    AsyncStorageAdapter: jest.fn().mockImplementation(() => ({
+      getItem: jest.fn().mockResolvedValue(null),
+      setItem: jest.fn().mockResolvedValue(undefined),
+      removeItem: jest.fn().mockResolvedValue(undefined),
+    })),
+  };
+});
+jest.mock("uuid", () => ({
+  v4: jest.fn(),
+}));
+
+jest.mock("@react-native-async-storage/async-storage", () => ({
+  getItem: jest.fn().mockResolvedValue(null),
+  setItem: jest.fn().mockResolvedValue(undefined),
+  removeItem: jest.fn().mockResolvedValue(undefined),
+}));
+
+jest.doMock("react-native", () => {
+  // Extend ReactNative
+  return Object.setPrototypeOf(
+    {
+      // Redefine an export, like a component
+      Button: "MockedButton",
+
+      // Mock out properties of an already mocked export
+      LayoutAnimation: {
+        ...ReactNative.LayoutAnimation,
+        configureNext: jest.fn(),
+      },
+
+      // Mock a native module
+      NativeModules: {
+        ...ReactNative.NativeModules,
+        MixpanelReactNative: {
+          initialize: jest.fn(),
+          setServerURL: jest.fn(),
+          setLoggingEnabled: jest.fn(),
+          setFlushOnBackground: jest.fn(),
+          setUseIpAddressForGeolocation: jest.fn(),
+          setFlushBatchSize: jest.fn(),
+          hasOptedOutTracking: jest.fn(),
+          optInTracking: jest.fn(),
+          optOutTracking: jest.fn(),
+          identify: jest.fn(),
+          alias: jest.fn(),
+          track: jest.fn(),
+          trackWithGroups: jest.fn(),
+          setGroup: jest.fn(),
+          getGroup: jest.fn(),
+          addGroup: jest.fn(),
+          removeGroup: jest.fn(),
+          deleteGroup: jest.fn(),
+          registerSuperProperties: jest.fn(),
+          registerSuperPropertiesOnce: jest.fn(),
+          unregisterSuperProperty: jest.fn(),
+          getSuperProperties: jest.fn(),
+          clearSuperProperties: jest.fn(),
+          timeEvent: jest.fn(),
+          eventElapsedTime: jest.fn(),
+          reset: jest.fn(),
+          getDistinctId: jest.fn(),
+          set: jest.fn(),
+          setOnce: jest.fn(),
+          increment: jest.fn(),
+          append: jest.fn(),
+          union: jest.fn(),
+          remove: jest.fn(),
+          unset: jest.fn(),
+          trackCharge: jest.fn(),
+          clearCharges: jest.fn(),
+          deleteUser: jest.fn(),
+          groupSetProperties: jest.fn(),
+          groupSetPropertyOnce: jest.fn(),
+          groupUnsetProperty: jest.fn(),
+          groupRemovePropertyValue: jest.fn(),
+          groupUnionProperty: jest.fn(),
+        },
+      },
+    },
+    ReactNative
+  );
+});