elixir: async tests

Provide tests to exercise the async callback type conversions.

Signed-off-by: Nathan Perry <nathan@tailscale.com>
Change-Id: Iafe01153ca52b9f618c80666de5e6f186a6a6964

Change-Id: I9d1d3e23de8a558fc6f0f81677b6237e6a6a6964
Signed-off-by: Nathan Perry <nathan@tailscale.com>

Author: npry

ts_elixir/config/config.exs

@@ -0,0 +1,7 @@
+import Config
+
+config :tailscale,
+  testing_nifs: false,
+  profile: :debug
+
+import_config "#{config_env()}.exs"

ts_elixir/config/dev.exs

@@ -0,0 +1,4 @@
+import Config
+
+config :tailscale,
+  testing_nifs: true

ts_elixir/config/prod.exs

@@ -0,0 +1,4 @@
+import Config
+
+config :tailscale,
+  profile: :release

ts_elixir/config/test.exs

@@ -0,0 +1,4 @@
+import Config
+
+config :tailscale,
+  testing_nifs: true

ts_elixir/lib/tailscale/native.ex

@@ -1,9 +1,20 @@
 defmodule Tailscale.Native do
+  @moduledoc false
+
+  @testing_nifs Application.compile_env!(:tailscale, :testing_nifs)
+  @profile Application.compile_env!(:tailscale, :profile)
+
+  @features (if @testing_nifs do
+               ["testing-nifs"]
+             else
+               []
+             end)
+
   use Rustler,
     otp_app: :tailscale,
-    crate: :ts_elixir
-
-  @moduledoc false
+    crate: :ts_elixir,
+    mode: @profile,
+    features: @features
 
   # The Elixir side of the Rustler bindings to `tailscale-rs`.
   #

ts_elixir/native/ts_elixir/Cargo.toml

@@ -20,6 +20,11 @@ tokio = { workspace = true, features = ["full"] }
 tracing = { workspace = true }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
+[features]
+# Additional testing functions that can directly trigger panics and errors to exercise the code in
+# development.
+testing-nifs = []
+
 [lib]
 crate-type = ["cdylib"]
 

ts_elixir/native/ts_elixir/src/lib.rs

@@ -16,6 +16,8 @@ mod helpers;
 mod ip_or_self;
 mod node_info;
 mod tcp;
+#[cfg(feature = "testing-nifs")]
+mod testing_nifs;
 mod udp;
 
 use async_reply::{AsyncReply, try_reply_async};

ts_elixir/native/ts_elixir/src/testing_nifs.rs

@@ -0,0 +1,50 @@
+//! NIFs that intentionally return errors, panic, and raise exceptions.
+//!
+//! These are intended for testing the async message passing code and require the
+//! `testing-nifs` feature flag to be enabled.
+
+use rustler::{Env, Error};
+
+use crate::async_reply::{AsyncReply, try_reply_async};
+
+#[rustler::nif]
+pub fn async_panic(env: Env, msg: Option<String>) -> AsyncReply {
+    try_reply_async(env, async move {
+        if let Some(msg) = msg {
+            panic!("{msg}");
+        } else {
+            panic!()
+        }
+
+        // Needed to indicate return type
+        #[allow(unreachable_code)]
+        Ok(())
+    })
+}
+
+#[rustler::nif]
+pub fn async_error<'e>(env: Env<'e>, s: String, atom: bool) -> AsyncReply<'e> {
+    try_reply_async(env, async move {
+        Result::<(), _>::Err(if atom {
+            Error::Atom(String::leak(s))
+        } else {
+            Error::Term(Box::new(s))
+        })
+    })
+}
+
+#[rustler::nif]
+pub fn async_raise<'e>(env: Env<'e>, s: String, atom: bool) -> AsyncReply<'e> {
+    try_reply_async(env, async move {
+        Result::<(), _>::Err(if atom {
+            Error::RaiseAtom(String::leak(s))
+        } else {
+            Error::RaiseTerm(Box::new(s))
+        })
+    })
+}
+
+#[rustler::nif]
+pub fn async_badarg<'e>(env: Env<'e>) -> AsyncReply<'e> {
+    try_reply_async(env, async move { Result::<(), _>::Err(Error::BadArg) })
+}

ts_elixir/test/async_callback_test.exs

@@ -0,0 +1,69 @@
+defmodule Tailscale.Test.AsyncCallbacks do
+  use ExUnit.Case, async: true
+  require Tailscale.Util
+  alias Tailscale.Native
+
+  defmacrop await(block, local) do
+    if local do
+      quote do
+        Tailscale.Util.await_local(unquote(block))
+      end
+    else
+      quote do
+        Tailscale.Util.await(unquote(block))
+      end
+    end
+  end
+
+  for local <- [true, false] do
+    describe "async calls (local: #{local})" do
+      for msg <- ["msg", nil] do
+        test "panic (msg: #{msg})" do
+          result = await(Native.async_panic(unquote(msg)), local)
+
+          {:error, {:nif_panic, arg}} = result
+
+          if unquote(msg) != nil do
+            assert(arg == "msg")
+          end
+        end
+      end
+
+      for atom <- [true, false] do
+        test "error (atom: #{atom})" do
+          assert(
+            await(Native.async_error("msg", unquote(atom)), local) ==
+              {:error,
+               if unquote(atom) do
+                 :msg
+               else
+                 "msg"
+               end}
+          )
+        end
+
+        test("raise (atom: #{atom})") do
+          assert_raise RuntimeError, fn ->
+            msg =
+              if unquote(atom) do
+                "Elixir.RuntimeError"
+              else
+                "msg"
+              end
+
+            await(
+              Native.async_raise(msg, unquote(atom)),
+              local
+            )
+          end
+        end
+      end
+
+      test "badarg" do
+        assert_raise ArgumentError, fn ->
+          await(Native.async_badarg(), local)
+        end
+      end
+    end
+  end
+end