mixpanel-react-native 3.1.2 → 3.2.0-beta.0

package/__tests__/flags.test.js

@@ -0,0 +1,730 @@
+import { Mixpanel } from "mixpanel-react-native";
+import { NativeModules } from "react-native";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+const mockNativeModule = NativeModules.MixpanelReactNative;
+
+// Mock fetch for JavaScript mode
+global.fetch = jest.fn();
+
+describe("Feature Flags", () => {
+  const testToken = "test-token-123";
+  let mixpanel;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    AsyncStorage.clear();
+    if (global.fetch.mockClear) {
+      global.fetch.mockClear();
+    }
+  });
+
+  describe("Flags Property Access", () => {
+    it("should expose flags property on Mixpanel instance", async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+
+      expect(mixpanel.flags).toBeDefined();
+    });
+
+    it("should lazy-load flags property", async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+
+      const flags1 = mixpanel.flags;
+      const flags2 = mixpanel.flags;
+
+      expect(flags1).toBe(flags2); // Should be same instance
+    });
+
+    it("should initialize flags when enabled in init options", async () => {
+      mockNativeModule.areFlagsReadySync.mockReturnValue(false);
+      mockNativeModule.loadFlags.mockResolvedValue(true);
+
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init(false, {}, "https://api.mixpanel.com", false, {
+        enabled: true,
+      });
+
+      expect(mockNativeModule.loadFlags).toHaveBeenCalledWith(testToken);
+    });
+  });
+
+  describe("Native Mode - Synchronous Methods", () => {
+    beforeEach(async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+    });
+
+    describe("areFlagsReady", () => {
+      it("should return false when flags are not ready", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(false);
+
+        const ready = mixpanel.flags.areFlagsReady();
+
+        expect(ready).toBe(false);
+        expect(mockNativeModule.areFlagsReadySync).toHaveBeenCalledWith(
+          testToken
+        );
+      });
+
+      it("should return true when flags are ready", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+
+        const ready = mixpanel.flags.areFlagsReady();
+
+        expect(ready).toBe(true);
+      });
+    });
+
+    describe("getVariantSync", () => {
+      const fallbackVariant = { key: "fallback", value: "default" };
+
+      it("should return fallback when flags not ready", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(false);
+
+        const variant = mixpanel.flags.getVariantSync("test-flag", fallbackVariant);
+
+        expect(variant).toEqual(fallbackVariant);
+        expect(mockNativeModule.getVariantSync).not.toHaveBeenCalled();
+      });
+
+      it("should get variant when flags are ready", () => {
+        const expectedVariant = { key: "treatment", value: "blue", experimentID: "exp123" };
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.getVariantSync.mockReturnValue(expectedVariant);
+
+        const variant = mixpanel.flags.getVariantSync("test-flag", fallbackVariant);
+
+        expect(variant).toEqual(expectedVariant);
+        expect(mockNativeModule.getVariantSync).toHaveBeenCalledWith(
+          testToken,
+          "test-flag",
+          fallbackVariant
+        );
+      });
+
+      it("should handle null feature name", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.getVariantSync.mockReturnValue(fallbackVariant);
+
+        const variant = mixpanel.flags.getVariantSync(null, fallbackVariant);
+
+        expect(variant).toEqual(fallbackVariant);
+      });
+    });
+
+    describe("getVariantValueSync", () => {
+      it("should return fallback when flags not ready", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(false);
+
+        const value = mixpanel.flags.getVariantValueSync("test-flag", "default");
+
+        expect(value).toBe("default");
+        expect(mockNativeModule.getVariantValueSync).not.toHaveBeenCalled();
+      });
+
+      it("should get value when flags are ready - iOS style", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.getVariantValueSync.mockReturnValue("blue");
+
+        const value = mixpanel.flags.getVariantValueSync("test-flag", "default");
+
+        expect(value).toBe("blue");
+      });
+
+      it("should handle Android wrapped response", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.getVariantValueSync.mockReturnValue({
+          type: "value",
+          value: "blue",
+        });
+
+        const value = mixpanel.flags.getVariantValueSync("test-flag", "default");
+
+        expect(value).toBe("blue");
+      });
+
+      it("should handle Android fallback response", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.getVariantValueSync.mockReturnValue({
+          type: "fallback",
+        });
+
+        const value = mixpanel.flags.getVariantValueSync("test-flag", "default");
+
+        expect(value).toBe("default");
+      });
+
+      it("should handle boolean values", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.getVariantValueSync.mockReturnValue(true);
+
+        const value = mixpanel.flags.getVariantValueSync("bool-flag", false);
+
+        expect(value).toBe(true);
+      });
+
+      it("should handle numeric values", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.getVariantValueSync.mockReturnValue(42);
+
+        const value = mixpanel.flags.getVariantValueSync("number-flag", 0);
+
+        expect(value).toBe(42);
+      });
+
+      it("should handle complex object values", () => {
+        const complexValue = {
+          nested: { array: [1, 2, 3], object: { key: "value" } },
+        };
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.getVariantValueSync.mockReturnValue(complexValue);
+
+        const value = mixpanel.flags.getVariantValueSync("complex-flag", null);
+
+        expect(value).toEqual(complexValue);
+      });
+    });
+
+    describe("isEnabledSync", () => {
+      it("should return fallback when flags not ready", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(false);
+
+        const enabled = mixpanel.flags.isEnabledSync("test-flag", false);
+
+        expect(enabled).toBe(false);
+        expect(mockNativeModule.isEnabledSync).not.toHaveBeenCalled();
+      });
+
+      it("should check if enabled when flags are ready", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.isEnabledSync.mockReturnValue(true);
+
+        const enabled = mixpanel.flags.isEnabledSync("test-flag", false);
+
+        expect(enabled).toBe(true);
+        expect(mockNativeModule.isEnabledSync).toHaveBeenCalledWith(
+          testToken,
+          "test-flag",
+          false
+        );
+      });
+
+      it("should use default fallback value of false", () => {
+        mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+        mockNativeModule.isEnabledSync.mockReturnValue(false);
+
+        mixpanel.flags.isEnabledSync("test-flag");
+
+        expect(mockNativeModule.isEnabledSync).toHaveBeenCalledWith(
+          testToken,
+          "test-flag",
+          false
+        );
+      });
+    });
+  });
+
+  describe("Native Mode - Asynchronous Methods", () => {
+    beforeEach(async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+    });
+
+    describe("loadFlags", () => {
+      it("should call native loadFlags method", async () => {
+        mockNativeModule.loadFlags.mockResolvedValue(true);
+
+        await mixpanel.flags.loadFlags();
+
+        expect(mockNativeModule.loadFlags).toHaveBeenCalledWith(testToken);
+      });
+
+      it("should handle errors gracefully", async () => {
+        mockNativeModule.loadFlags.mockRejectedValue(new Error("Network error"));
+
+        await expect(mixpanel.flags.loadFlags()).rejects.toThrow("Network error");
+      });
+    });
+
+    describe("getVariant - Promise pattern", () => {
+      const fallbackVariant = { key: "fallback", value: "default" };
+
+      it("should get variant async with Promise", async () => {
+        const expectedVariant = { key: "treatment", value: "blue" };
+        mockNativeModule.getVariant.mockResolvedValue(expectedVariant);
+
+        const variant = await mixpanel.flags.getVariant("test-flag", fallbackVariant);
+
+        expect(variant).toEqual(expectedVariant);
+        expect(mockNativeModule.getVariant).toHaveBeenCalledWith(
+          testToken,
+          "test-flag",
+          fallbackVariant
+        );
+      });
+
+      it("should return fallback on error", async () => {
+        mockNativeModule.getVariant.mockRejectedValue(new Error("Network error"));
+
+        const variant = await mixpanel.flags.getVariant("test-flag", fallbackVariant);
+
+        expect(variant).toEqual(fallbackVariant);
+      });
+    });
+
+    describe("getVariant - Callback pattern", () => {
+      const fallbackVariant = { key: "fallback", value: "default" };
+
+      it("should get variant async with callback", (done) => {
+        const expectedVariant = { key: "treatment", value: "blue" };
+        mockNativeModule.getVariant.mockResolvedValue(expectedVariant);
+
+        mixpanel.flags.getVariant("test-flag", fallbackVariant, (variant) => {
+          expect(variant).toEqual(expectedVariant);
+          done();
+        });
+      });
+
+      it("should return fallback on error with callback", (done) => {
+        mockNativeModule.getVariant.mockRejectedValue(new Error("Network error"));
+
+        mixpanel.flags.getVariant("test-flag", fallbackVariant, (variant) => {
+          expect(variant).toEqual(fallbackVariant);
+          done();
+        });
+      });
+    });
+
+    describe("getVariantValue - Promise pattern", () => {
+      it("should get value async with Promise", async () => {
+        mockNativeModule.getVariantValue.mockResolvedValue("blue");
+
+        const value = await mixpanel.flags.getVariantValue("test-flag", "default");
+
+        expect(value).toBe("blue");
+        expect(mockNativeModule.getVariantValue).toHaveBeenCalledWith(
+          testToken,
+          "test-flag",
+          "default"
+        );
+      });
+
+      it("should return fallback on error", async () => {
+        mockNativeModule.getVariantValue.mockRejectedValue(
+          new Error("Network error")
+        );
+
+        const value = await mixpanel.flags.getVariantValue("test-flag", "default");
+
+        expect(value).toBe("default");
+      });
+    });
+
+    describe("getVariantValue - Callback pattern", () => {
+      it("should get value async with callback", (done) => {
+        mockNativeModule.getVariantValue.mockResolvedValue("blue");
+
+        mixpanel.flags.getVariantValue("test-flag", "default", (value) => {
+          expect(value).toBe("blue");
+          done();
+        });
+      });
+
+      it("should return fallback on error with callback", (done) => {
+        mockNativeModule.getVariantValue.mockRejectedValue(
+          new Error("Network error")
+        );
+
+        mixpanel.flags.getVariantValue("test-flag", "default", (value) => {
+          expect(value).toBe("default");
+          done();
+        });
+      });
+    });
+
+    describe("isEnabled - Promise pattern", () => {
+      it("should check if enabled async with Promise", async () => {
+        mockNativeModule.isEnabled.mockResolvedValue(true);
+
+        const enabled = await mixpanel.flags.isEnabled("test-flag", false);
+
+        expect(enabled).toBe(true);
+        expect(mockNativeModule.isEnabled).toHaveBeenCalledWith(
+          testToken,
+          "test-flag",
+          false
+        );
+      });
+
+      it("should return fallback on error", async () => {
+        mockNativeModule.isEnabled.mockRejectedValue(new Error("Network error"));
+
+        const enabled = await mixpanel.flags.isEnabled("test-flag", false);
+
+        expect(enabled).toBe(false);
+      });
+    });
+
+    describe("isEnabled - Callback pattern", () => {
+      it("should check if enabled async with callback", (done) => {
+        mockNativeModule.isEnabled.mockResolvedValue(true);
+
+        mixpanel.flags.isEnabled("test-flag", false, (enabled) => {
+          expect(enabled).toBe(true);
+          done();
+        });
+      });
+
+      it("should return fallback on error with callback", (done) => {
+        mockNativeModule.isEnabled.mockRejectedValue(new Error("Network error"));
+
+        mixpanel.flags.isEnabled("test-flag", false, (enabled) => {
+          expect(enabled).toBe(false);
+          done();
+        });
+      });
+    });
+
+  });
+
+  // Note: JavaScript Mode tests are skipped as they require complex mocking
+  // of the mode switching logic. The JavaScript implementation is tested
+  // indirectly through the native mode tests and will be validated in integration testing.
+
+  describe("Error Handling", () => {
+    beforeEach(async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+    });
+
+    it("should not throw when native module methods fail", async () => {
+      mockNativeModule.loadFlags.mockRejectedValue(new Error("Native error"));
+
+      await expect(mixpanel.flags.loadFlags()).rejects.toThrow();
+    });
+
+    it("should return fallback values when errors occur in async methods", async () => {
+      mockNativeModule.getVariant.mockRejectedValue(new Error("Error"));
+
+      const fallback = { key: "fallback", value: "default" };
+      const variant = await mixpanel.flags.getVariant("test-flag", fallback);
+
+      expect(variant).toEqual(fallback);
+    });
+
+    it("should handle undefined callbacks gracefully", () => {
+      expect(() => {
+        mixpanel.flags.getVariant("test-flag", { key: "fallback", value: "default" });
+      }).not.toThrow();
+    });
+  });
+
+  describe("Edge Cases", () => {
+    beforeEach(async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+      mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+    });
+
+    it("should handle null feature names gracefully", async () => {
+      const fallback = { key: "fallback", value: "default" };
+      mockNativeModule.getVariantSync.mockReturnValue(fallback);
+      mockNativeModule.getVariantValueSync.mockReturnValue("default");
+
+      const variant = mixpanel.flags.getVariantSync(null, fallback);
+      expect(variant).toEqual(fallback);
+
+      const value = mixpanel.flags.getVariantValueSync(undefined, "default");
+      expect(value).toBe("default");
+    });
+
+    it("should handle empty string feature names", () => {
+      mockNativeModule.getVariantSync.mockReturnValue({
+        key: "fallback",
+        value: "default",
+      });
+
+      const variant = mixpanel.flags.getVariantSync("", {
+        key: "fallback",
+        value: "default",
+      });
+
+      expect(variant).toBeDefined();
+    });
+
+    it("should handle null variant values", () => {
+      mockNativeModule.getVariantValueSync.mockReturnValue(null);
+
+      const value = mixpanel.flags.getVariantValueSync("null-flag", "default");
+
+      expect(value).toBeNull();
+    });
+
+    it("should handle array variant values", () => {
+      const arrayValue = [1, 2, 3, "four"];
+      mockNativeModule.getVariantValueSync.mockReturnValue(arrayValue);
+
+      const value = mixpanel.flags.getVariantValueSync("array-flag", []);
+
+      expect(value).toEqual(arrayValue);
+    });
+  });
+
+  describe("Integration Tests", () => {
+    it("should support initialization with feature flags enabled", async () => {
+      mockNativeModule.loadFlags.mockResolvedValue(true);
+      mockNativeModule.initialize.mockResolvedValue(true);
+
+      const featureFlagsOptions = {
+        enabled: true,
+        context: {
+          platform: "mobile",
+          custom_properties: {
+            user_type: "premium",
+          },
+        },
+      };
+
+      mixpanel = new Mixpanel(testToken, true);
+      await mixpanel.init(false, {}, "https://api.mixpanel.com", true, featureFlagsOptions);
+
+      expect(mockNativeModule.initialize).toHaveBeenCalledWith(
+        testToken,
+        true,
+        false,
+        expect.any(Object),
+        "https://api.mixpanel.com",
+        true,
+        featureFlagsOptions
+      );
+      expect(mockNativeModule.loadFlags).toHaveBeenCalledWith(testToken);
+    });
+
+    it("should not load flags when feature flags are disabled", async () => {
+      mockNativeModule.initialize.mockResolvedValue(true);
+
+      mixpanel = new Mixpanel(testToken, true);
+      await mixpanel.init(false, {}, "https://api.mixpanel.com", true, {
+        enabled: false,
+      });
+
+      expect(mockNativeModule.loadFlags).not.toHaveBeenCalled();
+    });
+
+    it("should handle mixed mode usage - sync when ready, async when not", async () => {
+      mockNativeModule.areFlagsReadySync.mockReturnValue(false);
+      mockNativeModule.getVariant.mockResolvedValue({ key: "async", value: "result" });
+
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+
+      // Sync returns fallback when not ready
+      const syncVariant = mixpanel.flags.getVariantSync("test-flag", {
+        key: "fallback",
+        value: "default",
+      });
+      expect(syncVariant).toEqual({ key: "fallback", value: "default" });
+
+      // Async fetches from server
+      const asyncVariant = await mixpanel.flags.getVariant("test-flag", {
+        key: "fallback",
+        value: "default",
+      });
+      expect(asyncVariant).toEqual({ key: "async", value: "result" });
+    });
+  });
+
+  describe("Type Safety", () => {
+    beforeEach(async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+      mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+    });
+
+    it("should preserve string types", () => {
+      mockNativeModule.getVariantValueSync.mockReturnValue("string value");
+
+      const value = mixpanel.flags.getVariantValueSync("string-flag", "default");
+
+      expect(typeof value).toBe("string");
+      expect(value).toBe("string value");
+    });
+
+    it("should preserve boolean types", () => {
+      mockNativeModule.getVariantValueSync.mockReturnValue(true);
+
+      const value = mixpanel.flags.getVariantValueSync("bool-flag", false);
+
+      expect(typeof value).toBe("boolean");
+      expect(value).toBe(true);
+    });
+
+    it("should preserve number types", () => {
+      mockNativeModule.getVariantValueSync.mockReturnValue(42.5);
+
+      const value = mixpanel.flags.getVariantValueSync("number-flag", 0);
+
+      expect(typeof value).toBe("number");
+      expect(value).toBe(42.5);
+    });
+
+    it("should preserve object types", () => {
+      const objectValue = { nested: { key: "value" } };
+      mockNativeModule.getVariantValueSync.mockReturnValue(objectValue);
+
+      const value = mixpanel.flags.getVariantValueSync("object-flag", {});
+
+      expect(typeof value).toBe("object");
+      expect(value).toEqual(objectValue);
+    });
+
+    it("should preserve array types", () => {
+      const arrayValue = [1, "two", { three: 3 }];
+      mockNativeModule.getVariantValueSync.mockReturnValue(arrayValue);
+
+      const value = mixpanel.flags.getVariantValueSync("array-flag", []);
+
+      expect(Array.isArray(value)).toBe(true);
+      expect(value).toEqual(arrayValue);
+    });
+  });
+
+  describe("snake_case API Aliases (mixpanel-js compatibility)", () => {
+    beforeEach(async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+      mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+    });
+
+    it("should support are_flags_ready() alias", () => {
+      mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+
+      const ready = mixpanel.flags.are_flags_ready();
+
+      expect(ready).toBe(true);
+      expect(mockNativeModule.areFlagsReadySync).toHaveBeenCalledWith(testToken);
+    });
+
+    it("should support get_variant_sync() alias", () => {
+      const expectedVariant = { key: "treatment", value: "blue" };
+      mockNativeModule.getVariantSync.mockReturnValue(expectedVariant);
+
+      const variant = mixpanel.flags.get_variant_sync("test-flag", { key: "fallback", value: "default" });
+
+      expect(variant).toEqual(expectedVariant);
+    });
+
+    it("should support get_variant_value_sync() alias", () => {
+      mockNativeModule.getVariantValueSync.mockReturnValue("blue");
+
+      const value = mixpanel.flags.get_variant_value_sync("test-flag", "default");
+
+      expect(value).toBe("blue");
+    });
+
+    it("should support is_enabled_sync() alias", () => {
+      mockNativeModule.isEnabledSync.mockReturnValue(true);
+
+      const enabled = mixpanel.flags.is_enabled_sync("test-flag", false);
+
+      expect(enabled).toBe(true);
+    });
+
+    it("should support get_variant() async alias", async () => {
+      const expectedVariant = { key: "treatment", value: "blue" };
+      mockNativeModule.getVariant.mockResolvedValue(expectedVariant);
+
+      const variant = await mixpanel.flags.get_variant("test-flag", { key: "fallback", value: "default" });
+
+      expect(variant).toEqual(expectedVariant);
+    });
+
+    it("should support get_variant_value() async alias", async () => {
+      mockNativeModule.getVariantValue.mockResolvedValue("blue");
+
+      const value = await mixpanel.flags.get_variant_value("test-flag", "default");
+
+      expect(value).toBe("blue");
+    });
+
+    it("should support is_enabled() async alias", async () => {
+      mockNativeModule.isEnabled.mockResolvedValue(true);
+
+      const enabled = await mixpanel.flags.is_enabled("test-flag", false);
+
+      expect(enabled).toBe(true);
+    });
+  });
+
+  describe("updateContext (mixpanel-js alignment) - JavaScript mode only", () => {
+    beforeEach(async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+    });
+
+    it("should throw error in native mode with descriptive message", async () => {
+      await expect(
+        mixpanel.flags.updateContext({ user_tier: "premium" })
+      ).rejects.toThrow(
+        "updateContext() is not supported in native mode"
+      );
+    });
+
+    it("should throw error for update_context() snake_case alias in native mode", async () => {
+      await expect(
+        mixpanel.flags.update_context({ user_tier: "premium" })
+      ).rejects.toThrow(
+        "updateContext() is not supported in native mode"
+      );
+    });
+
+    it("should provide helpful error message about initialization", async () => {
+      await expect(
+        mixpanel.flags.updateContext({ user_tier: "premium" })
+      ).rejects.toThrow(
+        "Context must be set during initialization via FeatureFlagsOptions"
+      );
+    });
+
+    it("should indicate feature is JavaScript mode only", async () => {
+      await expect(
+        mixpanel.flags.updateContext({ user_tier: "premium" })
+      ).rejects.toThrow(
+        "This feature is only available in JavaScript mode"
+      );
+    });
+
+    // Note: Testing actual JavaScript mode behavior would require complex mocking
+    // of the mode switching logic. The JavaScript implementation is tested
+    // indirectly through integration testing with Expo/RN Web environments.
+  });
+
+  describe("Boolean Validation Enhancement (mixpanel-js alignment)", () => {
+    beforeEach(async () => {
+      mixpanel = new Mixpanel(testToken, false);
+      await mixpanel.init();
+      mockNativeModule.areFlagsReadySync.mockReturnValue(true);
+    });
+
+    it("should validate boolean values in isEnabledSync", () => {
+      // Note: This test validates the native implementation should perform boolean validation
+      // The JavaScript implementation has this validation, but native mode delegates to native code
+      mockNativeModule.isEnabledSync.mockReturnValue(true);
+
+      const enabled = mixpanel.flags.isEnabledSync("bool-flag", false);
+
+      expect(typeof enabled).toBe("boolean");
+    });
+
+    it("should handle non-boolean values gracefully", () => {
+      // The native implementation should coerce or validate non-boolean values
+      mockNativeModule.isEnabledSync.mockReturnValue(false);
+
+      const enabled = mixpanel.flags.isEnabledSync("string-flag", false);
+
+      expect(typeof enabled).toBe("boolean");
+    });
+  });
+});