wrap new facilities in ipc feature

Author: rkuhn

Cargo.toml

@@ -10,13 +10,18 @@ description = "Network simulator."
 license = "MIT"
 repository = "https://github.com/ipfs-rust/netsim-embed"
 
+[features]
+ipc = ["dep:libtest-mimic", "dep:anyhow", "dep:ipc-channel"]
+
 [dependencies]
+anyhow = { version = "1.0.40", optional = true }
 async-global-executor = "2.0.2"
 async-process = "1.0.2"
 dlopen = "0.1.8"
 futures = "0.3.13"
-ipc-channel = "0.16.0"
+ipc-channel = { version = "0.16.0", optional = true }
 libpacket = "0.1.0"
+libtest-mimic = { version = "0.6.0", optional = true }
 log = "0.4.14"
 netsim-embed-core = { version = "0.4.2", path = "core" }
 netsim-embed-machine = { version = "0.6.1", path = "machine" }
@@ -32,11 +37,11 @@ async-trait = "0.1.50"
 env_logger = "0.8.3"
 if-watch = "0.2.2"
 ipnet = "2.3.0"
-libtest-mimic = "0.6.0"
 netsim-embed-cli = { path = "cli" }
 udp-socket = "0.1.1"
 
 [[test]]
 name = "smoke_test"
 path = "tests/smoke_test.rs"
 harness = false
+required-features = ["ipc"]

src/lib.rs

@@ -1,7 +1,6 @@
 use async_process::Command;
 use dlopen::raw::AddressInfoObtainer;
 use futures::prelude::*;
-use ipc_channel::ipc::{IpcOneShotServer, IpcReceiver, IpcSender};
 pub use libpacket::*;
 use netsim_embed_core::*;
 pub use netsim_embed_core::{DelayBuffer, Ipv4Range, Protocol};
@@ -73,12 +72,13 @@ where
         &mut self.machines
     }
 
+    #[cfg(feature = "ipc")]
     pub async fn spawn<T: 'static + Send>(
         &mut self,
-        function: fn(IpcReceiver<T>),
-    ) -> (MachineId, IpcSender<T>) {
+        function: fn(ipc_channel::ipc::IpcReceiver<T>),
+    ) -> (MachineId, ipc_channel::ipc::IpcSender<T>) {
         let name = get_fn_name(function);
-        let (server, server_name) = IpcOneShotServer::new().unwrap();
+        let (server, server_name) = ipc_channel::ipc::IpcOneShotServer::new().unwrap();
         let mut command = Command::new(std::env::current_exe().unwrap());
         command.args(["--netsim-embed-internal-call", &name, &server_name]);
         let machine = self.spawn_machine(command, None).await;
@@ -205,7 +205,8 @@ where
     }
 }
 
-pub fn get_fn_name<T>(function: fn(IpcReceiver<T>)) -> String {
+#[cfg(feature = "ipc")]
+pub fn get_fn_name<T>(function: fn(ipc_channel::ipc::IpcReceiver<T>)) -> String {
     let info = AddressInfoObtainer::new()
         .obtain(function as *const ())
         .expect("look up existing function pointer");
@@ -269,8 +270,9 @@ pub struct NatConfig {
 ///     println!("cargo:rustc-link-arg-tests=-rdynamic");
 /// }
 /// ```
+#[cfg(feature = "ipc")]
 #[macro_export]
-macro_rules! dispatch_args {
+macro_rules! declare_machines {
     ( $($fn:path),* ) => {{
         let mut args = std::env::args();
         args.next();
@@ -279,8 +281,8 @@ macro_rules! dispatch_args {
             let server_name = args.next().unwrap();
             $(
                 if function == $crate::get_fn_name($fn) {
-                    let (sender, receiver) = ipc_channel::ipc::channel().unwrap();
-                    let server_sender = ipc_channel::ipc::IpcSender::connect(server_name).unwrap();
+                    let (sender, receiver) = $crate::test_util::ipc::channel().unwrap();
+                    let server_sender = $crate::test_util::ipc::IpcSender::connect(server_name).unwrap();
                     server_sender.send(sender).unwrap();
                     $fn(receiver);
                     std::process::exit(0);
@@ -290,3 +292,41 @@ macro_rules! dispatch_args {
         }
     }}
 }
+
+#[cfg(feature = "ipc")]
+pub mod test_util {
+    pub struct TestResult(anyhow::Result<()>);
+    impl TestResult {
+        pub fn into_inner(self) -> anyhow::Result<()> {
+            self.0
+        }
+    }
+    impl From<()> for TestResult {
+        fn from(_: ()) -> Self {
+            Self(Ok(()))
+        }
+    }
+    impl<E: std::error::Error + Send + Sync + 'static> From<Result<(), E>> for TestResult {
+        fn from(res: Result<(), E>) -> Self {
+            Self(res.map_err(Into::into))
+        }
+    }
+    pub use ipc_channel::ipc;
+    pub use libtest_mimic::{run, Arguments, Trial};
+}
+
+#[cfg(feature = "ipc")]
+#[macro_export]
+macro_rules! run_tests {
+    ( $($fn:path),* ) => {{
+        $crate::unshare_user().unwrap();
+        let args = $crate::test_util::Arguments::from_args();
+        let tests = vec![
+            $($crate::test_util::Trial::test(stringify!($fn), || {
+                $crate::test_util::TestResult::from($fn()).into_inner()?;
+                Ok(())
+            })),*
+        ];
+        $crate::test_util::run(&args, tests).exit();
+    }};
+}

tests/smoke_test.rs

@@ -43,24 +43,6 @@ fn one_plus_one_makes_two() {
 }
 
 fn main() {
-    netsim_embed::dispatch_args!(send_one, add);
-    netsim_embed::unshare_user().unwrap();
-    let args = libtest_mimic::Arguments::from_args();
-    let mktest = |f: fn()| {
-        move || {
-            f();
-            Ok(())
-        }
-    };
-    libtest_mimic::run(
-        &args,
-        vec![
-            libtest_mimic::Trial::test("can_send_one", mktest(can_send_one)),
-            libtest_mimic::Trial::test("one_plus_one_makes_two", || {
-                one_plus_one_makes_two();
-                Ok(())
-            }),
-        ],
-    )
-    .exit();
+    netsim_embed::declare_machines!(send_one, add);
+    netsim_embed::run_tests!(can_send_one, one_plus_one_makes_two);
 }