@pomwik/afterdb-react 0.0.0-stage → 0.20.2

package/src/__tests__/mocks.ts

@@ -0,0 +1,154 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2024 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+import { act } from "@testing-library/react-native";
+import { EstimateProgressNotificationCallback, ProgressRealmPromise, Realm } from "realm";
+import { sleep } from "./helpers";
+
+/**
+ * Mocks {@link Realm.ProgressRealmPromise} with a custom
+ * promise completion and progress handler.
+ */
+export class MockedProgressRealmPromise extends Promise<Realm> implements ProgressRealmPromise {
+  private progressHandler?: (callback: EstimateProgressNotificationCallback) => void;
+  private cancelHandler?: () => void;
+  private realmPromise!: Promise<Realm>;
+
+  constructor(
+    getRealm: () => Promise<Realm>,
+    options?: {
+      progress?: (callback: EstimateProgressNotificationCallback) => void;
+      cancel?: () => void;
+    },
+  ) {
+    let realmPromise: Promise<Realm>;
+    super((resolve) => {
+      realmPromise = getRealm();
+      realmPromise.then((realm) => resolve(realm));
+    });
+    // @ts-expect-error realmPromise value will be assigned right away
+    this.realmPromise = realmPromise;
+    this.progressHandler = options?.progress;
+    this.cancelHandler = options?.cancel;
+  }
+
+  get [Symbol.toStringTag]() {
+    return "MockedProgressRealmPromise";
+  }
+
+  cancel = () => {
+    if (!this.cancelHandler) {
+      throw new Error("cancel handler not set");
+    }
+    this.cancelHandler();
+  };
+
+  then<TResult1 = Realm, TResult2 = never>(
+    onfulfilled?: ((value: Realm) => TResult1 | PromiseLike<TResult1>) | null | undefined,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.realmPromise.then(onfulfilled, onrejected);
+  }
+
+  progress = (callback: EstimateProgressNotificationCallback) => {
+    if (!this.progressHandler) {
+      throw new Error("progress handler not set");
+    }
+    this.progressHandler(callback);
+    return this;
+  };
+}
+
+/**
+ * Mocked {@link ProgressRealmPromise} which resolves after a set delay.
+ * If `options.progressValues` is specified, passes it through an
+ * equal interval to `Realm.open(...).progress(...)` callback.
+ */
+export class MockedProgressRealmPromiseWithDelay extends MockedProgressRealmPromise {
+  public currentProgressIndex = 0;
+  public progressValues: number[] | undefined;
+  private progressTimeout: NodeJS.Timeout | undefined;
+
+  constructor(
+    options: {
+      delay?: number;
+      /** Progress values which the `Realm.open(...).progress(...)` will receive in an equal interval. */
+      progressValues?: number[];
+    } = {},
+  ) {
+    const { progressValues, delay = 100 } = options;
+    super(
+      async () => {
+        await sleep(delay);
+        return new Realm();
+      },
+      {
+        progress: (callback) => {
+          this.progressTimeout = callMockedProgressNotifications(callback, delay, progressValues);
+        },
+        cancel: () => clearTimeout(this.progressTimeout),
+      },
+    );
+    this.progressValues = progressValues;
+  }
+}
+
+/** Calls given callbacks with progressValues in an equal interval */
+export function callMockedProgressNotifications(
+  callback: EstimateProgressNotificationCallback,
+  timeFrame: number,
+  progressValues: number[] = [0, 0.25, 0.5, 0.75, 1],
+): NodeJS.Timeout {
+  let progressIndex = 0;
+  let progressInterval: NodeJS.Timeout | undefined = undefined;
+  const sendProgress = () => {
+    // Uses act as this causes a component state update.
+    act(() => callback(progressValues[progressIndex]));
+    progressIndex++;
+
+    if (progressIndex >= progressValues.length) {
+      // Send the next progress update in equidistant time
+      clearInterval(progressInterval);
+    }
+  };
+  progressInterval = setInterval(sendProgress, timeFrame / (progressValues.length + 1));
+  sendProgress();
+  return progressInterval;
+}
+
+/**
+ * Mocks the Realm.open operation with a delayed, predictable Realm creation.
+ * @returns Promise which resolves when the Realm is opened.
+ */
+export function mockRealmOpen(
+  progressRealmPromise: MockedProgressRealmPromise = new MockedProgressRealmPromiseWithDelay(),
+): MockedProgressRealmPromise {
+  const delayedRealmOpen = jest.spyOn(Realm, "open");
+  delayedRealmOpen.mockImplementation(() => progressRealmPromise);
+  return progressRealmPromise;
+}
+
+/** Mocks a {@link Realm} with a custom syncSession and returns it. */
+export function mockSyncedRealm({ syncSession }: { syncSession: Partial<Realm["syncSession"]> }) {
+  const mockedSyncedRealm = new Realm();
+
+  //@ts-expect-error The mock currently supports supplying a subset of methods
+  jest.replaceProperty(mockedSyncedRealm, "syncSession", syncSession);
+
+  return mockedSyncedRealm;
+}

package/src/__tests__/profileHook.tsx

@@ -0,0 +1,76 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2024 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+import React, { Profiler, ProfilerOnRenderCallback } from "react";
+import { renderHook, RenderHookResult, RenderHookOptions } from "@testing-library/react-native";
+
+function generateProfilerId() {
+  const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+  return `test-${nonce}`;
+}
+
+type RenderEvent = {
+  phase: "mount" | "update";
+  actualDuration: number;
+  baseDuration: number;
+};
+
+type ProfileWrapper = {
+  wrapper: React.ComponentType<React.PropsWithChildren>;
+  renders: RenderEvent[];
+};
+
+function createProfilerWrapper(Parent: undefined | React.ComponentType<React.PropsWithChildren>): ProfileWrapper {
+  const renders: RenderEvent[] = [];
+  const id = generateProfilerId();
+  const handleRender: ProfilerOnRenderCallback = (
+    id,
+    phase,
+    actualDuration,
+    baseDuration,
+    startTime,
+    commitTime,
+    interactions,
+  ) => {
+    renders.push({ phase, actualDuration, baseDuration });
+  };
+
+  const Wrapper: React.ComponentType<React.PropsWithChildren> = ({ children }) => (
+    <Profiler id={id} onRender={handleRender} children={children} />
+  );
+
+  return {
+    wrapper: Parent
+      ? ({ children }) => (
+          <Parent>
+            <Wrapper children={children} />
+          </Parent>
+        )
+      : Wrapper,
+    renders,
+  };
+}
+
+export function profileHook<Result, Props>(
+  callback: (props: Props) => Result,
+  options?: RenderHookOptions<Props>,
+): RenderHookResult<Result, Props> & { renders: RenderEvent[] } {
+  const { wrapper, renders } = createProfilerWrapper(options?.wrapper);
+  const result = renderHook<Result, Props>(callback, { ...options, wrapper });
+  return { ...result, renders };
+}

package/src/__tests__/setup.ts

@@ -0,0 +1,22 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2024 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+import Realm from "realm";
+Realm.flags.THROW_ON_GLOBAL_REALM = true;
+// Enable calling Realm.clearTestState()
+Realm.flags.ALLOW_CLEAR_TEST_STATE = true;

package/src/__tests__/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "types": [
+      "jest",
+      "node",
+      "@testing-library/react-native/extend-expect",
+    ]
+  },
+  "include": [
+    "."
+  ],
+  "exclude": []
+}

package/src/__tests__/useObjectHook.test.tsx

@@ -0,0 +1,158 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2021 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+import Realm from "realm";
+import { renderHook } from "@testing-library/react-native";
+import assert from "node:assert";
+
+import { createUseObject } from "../useObject";
+import { createRealmTestContext } from "./createRealmTestContext";
+import { profileHook } from "./profileHook";
+
+const dogSchema: Realm.ObjectSchema = {
+  name: "dog",
+  primaryKey: "_id",
+  properties: {
+    _id: "int",
+    name: "string",
+    age: "int",
+  },
+};
+
+interface IDog {
+  _id: number;
+  name: string;
+  age: number;
+}
+
+const context = createRealmTestContext({ schema: [dogSchema] });
+const useObject = createUseObject(context.useRealm);
+
+const testDataSet = [
+  { _id: 4, name: "Vincent", age: 5 },
+  { _id: 5, name: "River", age: 25 },
+  { _id: 6, name: "Schatzi", age: 13 },
+];
+
+describe("useObject", () => {
+  beforeEach(() => {
+    const realm = context.openRealm();
+    realm.write(() => {
+      realm.deleteAll();
+      testDataSet.forEach((data) => {
+        realm.create("dog", data);
+      });
+    });
+  });
+
+  afterEach(() => {
+    context.cleanup();
+  });
+
+  it("can retrieve a single object using useObject", () => {
+    const [, river] = testDataSet;
+    const { result } = renderHook(() => useObject<IDog>("dog", river._id));
+    const object = result.current;
+    expect(object).toMatchObject(river);
+  });
+
+  describe("missing objects", () => {
+    it("return null", () => {
+      const { result } = renderHook(() => useObject<IDog>("dog", 12));
+      expect(result.current).toEqual(null);
+    });
+
+    it("rerenders and return object once created", () => {
+      const { write, realm } = context;
+      const { result, renders } = profileHook(() => useObject<IDog>("dog", 12));
+      expect(renders).toHaveLength(1);
+      expect(result.current).toEqual(null);
+      write(() => {
+        realm.create<IDog>("dog", { _id: 12, name: "Lassie", age: 32 });
+      });
+      expect(renders).toHaveLength(2);
+      expect(result.current?.name).toEqual("Lassie");
+    });
+  });
+
+  describe("key-path filtering", () => {
+    it("can filter notifications using key-path array", async () => {
+      const [vincent] = testDataSet;
+      const { write } = context;
+      const { result, renders } = profileHook(() => useObject<IDog>("dog", vincent._id, ["name"]));
+      expect(renders).toHaveLength(1);
+      expect(result.current).toMatchObject(vincent);
+      // Update the name and expect a re-render
+      write(() => {
+        assert(result.current);
+        result.current.name = "Vince!";
+      });
+      expect(renders).toHaveLength(2);
+      expect(result.current?.name).toEqual("Vince!");
+      // Update the age and don't expect a re-render
+      write(() => {
+        assert(result.current);
+        result.current.age = 5;
+      });
+      expect(renders).toHaveLength(2);
+    });
+
+    it("can filter notifications using key-path string", async () => {
+      const [vincent] = testDataSet;
+      const { write } = context;
+      const { result, renders } = profileHook(() => useObject<IDog>("dog", vincent._id, "age"));
+      expect(renders).toHaveLength(1);
+      expect(result.current).toMatchObject(vincent);
+      // Update the name and expect a re-render
+      write(() => {
+        assert(result.current);
+        result.current.age = 13;
+      });
+      expect(renders).toHaveLength(2);
+      expect(result.current?.age).toEqual(13);
+      // Update the age and don't expect a re-render
+      write(() => {
+        assert(result.current);
+        result.current.name = "Vince!";
+      });
+      expect(renders).toHaveLength(2);
+    });
+  });
+
+  describe("passing options object as argument", () => {
+    it("rerenders on updates", () => {
+      const { write, realm } = context;
+
+      const vincent = realm.objectForPrimaryKey("dog", 4);
+      assert(vincent);
+
+      const { result, renders } = profileHook(() => useObject<IDog>({ type: "dog", primaryKey: 4, keyPaths: "name" }));
+      expect(renders).toHaveLength(1);
+      write(() => {
+        vincent.name = "Vinnie";
+      });
+      expect(renders).toHaveLength(2);
+      expect(result.current?.name).toEqual("Vinnie");
+      // Expect no renders when updating a property outside key-paths
+      write(() => {
+        vincent.age = 30;
+      });
+      expect(renders).toHaveLength(2);
+    });
+  });
+});