Add reproduction for uniffi arc objects

Author: Daniel Salinas

fixtures/objects/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "uniffi-fixtures-objects"
+version = "0.21.0"
+authors = ["zzorba"]
+edition = "2021"
+license = "MPL-2.0"
+publish = false
+
+[lib]
+name = "objects"
+crate-type = ["lib", "cdylib"]
+
+[dependencies]
+anyhow = "1"
+uniffi = { workspace = true, features = ["tokio", "cli"] }
+async-trait = "0.1"
+futures = "0.3"
+thiserror = "1.0"
+tokio = { version = "1.24.1", features = ["time", "sync"] }
+once_cell = "1.18.0"
+ubrn_testing = { path = "../../crates/ubrn_testing" }
+
+[build-dependencies]
+uniffi = { workspace = true, features = ["build"] }
+
+[dev-dependencies]
+uniffi = { workspace = true, features = ["bindgen-tests"] }

fixtures/objects/README.md

@@ -0,0 +1,39 @@
+# A basic test for uniffi components
+
+This test covers async functions and methods. It also provides examples.
+
+## Run the tests
+
+Simply use `cargo`:
+
+```sh
+$ cargo test
+```
+
+It is possible to filter by test names, like `cargo test -- swift` to only run
+Swift's tests.
+
+## Run the examples
+
+At the time of writing, each `examples/*` directory has a `Makefile`. They are
+mostly designed for Unix-ish systems, sorry for that.
+
+To run the examples, first `uniffi` must be compiled:
+
+```sh
+$ cargo build --release -p uniffi`
+```
+
+Then, each `Makefile` has 2 targets: `build` and `run`:
+
+```sh
+$ # Build the examples.
+$ make build
+$
+$ # Run the example.
+$ make run
+```
+
+One note for `examples/kotlin/`, some JAR files must be present, so please
+run `make install-jar` first: It will just download the appropriated JAR files
+directly inside the directory from Maven.

fixtures/objects/src/lib.rs

@@ -0,0 +1,73 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/
+ */
+
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+
+#[cfg(not(target_arch = "wasm32"))]
+type EventHandlerFut = Pin<Box<dyn Future<Output = ()> + Send>>;
+#[cfg(target_arch = "wasm32")]
+type EventHandlerFut = Pin<Box<dyn Future<Output = ()>>>;
+
+#[cfg(not(target_arch = "wasm32"))]
+type EventHandlerFn = dyn Fn(u64) -> EventHandlerFut + Send + Sync;
+#[cfg(target_arch = "wasm32")]
+type EventHandlerFn = dyn Fn(u64) -> EventHandlerFut;
+
+
+// Async callback interface implemented in foreign code
+#[derive(uniffi::Object)]
+pub struct SimpleObject {
+  inner: Arc<InnerObject>
+}
+
+#[derive(Debug, thiserror::Error, uniffi::Error)]
+#[uniffi(flat_error)]
+enum ClientError {
+  #[error("Password is too weak")]
+  Error(String),
+}
+
+#[uniffi::export]
+impl SimpleObject {
+  async fn builder_pattern(&self, key: String) -> Result<Arc<SimpleObject>, ClientError> {
+    Ok(Arc::new(SimpleObject {
+        inner: Arc::new(InnerObject {
+            foo: Foo {
+                key,
+                value: 42,
+            },
+            callbacks: vec![],
+        }),
+    }))
+  }
+}
+
+pub struct InnerObject {
+  pub foo: Foo,
+  pub callbacks: Vec<Box<EventHandlerFn>>,
+}
+
+pub struct Foo {
+  pub key: String,
+  pub value: u64,
+}
+
+#[uniffi::export]
+async fn make_object() -> Arc<SimpleObject> {
+    Arc::new(SimpleObject {
+        inner: Arc::new(InnerObject {
+            foo: Foo {
+                key: "key".to_string(),
+                value: 42,
+            },
+            callbacks: vec![],
+        }),
+    })
+}
+
+uniffi::setup_scaffolding!();

fixtures/objects/tests/bindings/.supported-flavors.txt

@@ -0,0 +1,2 @@
+jsi
+wasm

fixtures/objects/tests/bindings/test_async_callbacks.ts

@@ -0,0 +1,224 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/
+ */
+
+import myModule, {
+  asStringUsingTrait,
+  AsyncParser,
+  cancelDelayUsingTrait,
+  delayUsingTrait,
+  ParserError,
+  tryDelayUsingTrait,
+  tryFromStringUsingTrait,
+} from "../../generated/async_callbacks";
+import { asyncTest, Asserts, test } from "@/asserts";
+import {
+  uniffiRustFutureHandleCount,
+  uniffiForeignFutureHandleCount,
+} from "uniffi-bindgen-react-native";
+import "@/polyfills";
+
+// Initialize the callbacks for the module.
+// This will be hidden in the installation process.
+myModule.initialize();
+
+function delayPromise(delayMs: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
+function cancellableDelayPromise(
+  delayMs: number,
+  abortSignal: AbortSignal,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, delayMs);
+    abortSignal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(abortSignal.reason);
+    });
+  });
+}
+
+function checkRemainingFutures(t: Asserts) {
+  t.assertEqual(
+    0,
+    uniffiRustFutureHandleCount(),
+    "Number of remaining futures should be zero",
+  );
+  t.assertEqual(
+    0,
+    uniffiForeignFutureHandleCount(),
+    "Number of remaining foreign futures should be zero",
+  );
+}
+
+(async () => {
+  // AsyncParser.
+  class TsAsyncParser implements AsyncParser {
+    constructor(public completedDelays: number = 0) {}
+    async asString(delayMs: number, value: number): Promise<string> {
+      await this.doDelay(delayMs);
+      return value.toString();
+    }
+    async tryFromString(delayMs: number, value: string): Promise<number> {
+      if (value == "force-panic") {
+        throw new Error("force-panic");
+      }
+      if (value == "force-unexpected-exception") {
+        throw new ParserError.UnexpectedError();
+      }
+      const v = this.parseInt(value);
+      await this.doDelay(delayMs);
+      return v;
+    }
+    async delay(delayMs: number): Promise<void> {
+      await this.doDelay(delayMs);
+    }
+    async tryDelay(delayMs: string): Promise<void> {
+      await this.doDelay(this.parseInt(delayMs));
+    }
+
+    toString(): string {
+      return "TsAsyncParser";
+    }
+
+    private async doDelay(ms: number): Promise<void> {
+      await delayPromise(ms);
+      this.completedDelays += 1;
+    }
+
+    private parseInt(value: string): number {
+      const num = Number.parseInt(value);
+      if (Number.isNaN(num)) {
+        throw new ParserError.NotAnInt();
+      }
+      return num;
+    }
+  }
+
+  await asyncTest("Async callbacks", async (t) => {
+    const traitObj = new TsAsyncParser();
+
+    const result = await asStringUsingTrait(traitObj, 1, 42);
+    t.assertEqual(result, "42");
+
+    const result2 = await tryFromStringUsingTrait(traitObj, 1, "42");
+    t.assertEqual(result2, 42);
+
+    await delayUsingTrait(traitObj, 1);
+    await tryDelayUsingTrait(traitObj, "1");
+    checkRemainingFutures(t);
+    t.end();
+  });
+
+  await asyncTest("Async callbacks with errors", async (t) => {
+    const traitObj = new TsAsyncParser();
+
+    try {
+      await tryFromStringUsingTrait(traitObj, 1, "force-panic");
+      t.fail("No error detected");
+    } catch (e: any) {
+      // OK
+      t.assertTrue(ParserError.UnexpectedError.instanceOf(e));
+    }
+
+    try {
+      await tryFromStringUsingTrait(traitObj, 1, "fourty-two");
+      t.fail("No error detected");
+    } catch (e: any) {
+      t.assertTrue(ParserError.NotAnInt.instanceOf(e));
+    }
+
+    await t.assertThrowsAsync(
+      ParserError.NotAnInt.instanceOf,
+      async () => await tryFromStringUsingTrait(traitObj, 1, "fourty-two"),
+    );
+    await t.assertThrowsAsync(
+      ParserError.UnexpectedError.instanceOf,
+      async () =>
+        await tryFromStringUsingTrait(
+          traitObj,
+          1,
+          "force-unexpected-exception",
+        ),
+    );
+
+    try {
+      await tryDelayUsingTrait(traitObj, "one");
+      t.fail("Expected previous statement to throw");
+    } catch (e: any) {
+      // Expected
+    }
+    checkRemainingFutures(t);
+    t.end();
+  });
+
+  class CancellableTsAsyncParser extends TsAsyncParser {
+    /**
+     * Each async callback method has an additional optional argument
+     * `asyncOptions_`. This contains an `AbortSignal`.
+     *
+     * If the Rust task is cancelled, then this abort signal is
+     * told, which can be used to co-operatively cancel the
+     * async callback.
+     *
+     * @param delayMs
+     * @param asyncOptions_
+     */
+    async delay(
+      delayMs: number,
+      asyncOptions_?: { signal: AbortSignal },
+    ): Promise<void> {
+      await this.doCancellableDelay(delayMs, asyncOptions_?.signal);
+    }
+
+    private async doCancellableDelay(
+      ms: number,
+      signal?: AbortSignal,
+    ): Promise<void> {
+      if (signal) {
+        await cancellableDelayPromise(ms, signal);
+      } else {
+        await delayPromise(ms);
+      }
+      this.completedDelays += 1;
+    }
+  }
+
+  /**
+   * Rust supports task cancellation, but it's not automatic. It is rather like
+   * Javascript's.
+   *
+   * In Javascript, an `AbortController` is used to make an `AbortSignal`.
+   *
+   * The task itself periodically checks the `AbortSignal` (or listens for an `abort` event),
+   * then takes abortive actions. This usually happens when the `AbortController.abort` method
+   * is called.
+   *
+   * In Rust, an `AbortHandle` is analagous to the `AbortController`.
+   *
+   * This test checks if that signal is being triggered by a Rust.
+   */
+  await asyncTest("cancellation of async JS callbacks", async (t) => {
+    const traitObj = new CancellableTsAsyncParser();
+
+    // #JS_TASK_CANCELLATION
+    const completedDelaysBefore = traitObj.completedDelays;
+    // This method calls into the async callback to sleep (in Javascript) for 100 seconds.
+    // On a different thread, in Rust, it cancels the task. This sets the `AbortSignal` passed to the
+    // callback function.
+    await cancelDelayUsingTrait(traitObj, 10000);
+    // If the task was cancelled, then completedDelays won't have increased.
+    t.assertEqual(
+      traitObj.completedDelays,
+      completedDelaysBefore,
+      "Delay should have been cancelled",
+    );
+
+    // Test that all handles here cleaned up
+    checkRemainingFutures(t);
+    t.end();
+  });
+})();

fixtures/objects/tests/test_generated_bindings.rs

@@ -0,0 +1,5 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/
+ */

fixtures/objects/uniffi.toml

@@ -0,0 +1,3 @@
+[bindings.typescript]
+logLevel = "debug"
+consoleImport = "@/hermes"