Project Skeleton

Cargo.toml

@@ -2,7 +2,27 @@
 name = "didethresolver"
 version = "0.1.0"
 edition = "2021"
+resolver = "2"
 
+[profile.release]
+panic = 'abort'
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+log = "0.4"
+tokio = { version = "1.34", features = ["macros", "rt"] }
+async-trait = "0.1"
+tracing = "0.1"
+tracing-subscriber = "0.3.18"
+tracing-forest = { version = "0.1", features = ["ansi", "chrono", "env-filter"] }
+serde = { version = "1", features = ["derive"] }
+jsonrpsee = { version = "0.20", features = ["macros", "server", "client-core"] }
+anyhow = "1"
+
+[dev-dependencies]
+mockall = "0.11"
+jsonrpsee = { version = "0.20", features = ["macros", "server", "client"] }
+futures = "0.3"
+tokio = { version = "1.34", features = ["macros", "rt", "time"] }
+
+

rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "stable"
+components = [ "rustc", "cargo", "clippy", "rustfmt", "rust-analyzer" ]
+profile = "default"

src/main.rs

@@ -1,3 +1,16 @@
+mod rpc;
+mod types;
+mod util;
+
 fn main() {
+    util::init_logging();
     println!("Hello, world!");
 }
+
+/*
+pub async fn run_server() -> Result<(), Error> {
+    let server = Server::builder().build("127.0.0.1:0").await?;
+    let addr = server.local_addr()?;
+    let handle = server.start(DidRegistryMethods);
+}
+*/

src/rpc.rs

@@ -0,0 +1,51 @@
+mod api;
+mod methods;
+
+// re-export the defined API
+pub use api::*;
+
+#[cfg(test)]
+mod tests {
+    use std::{future::Future, time::Duration};
+
+    use futures::future::FutureExt;
+    use jsonrpsee::{
+        server::Server,
+        ws_client::{WsClient, WsClientBuilder},
+    };
+    use tokio::time::timeout as timeout_tokio;
+
+    use super::*;
+
+    // Test harness for using a WebSockets Server
+    pub async fn with_client<F, R, T>(timeout: Option<Duration>, fun: F) -> T
+    where
+        F: FnOnce(WsClient) -> R + 'static,
+        R: Future<Output = T> + FutureExt + Send + 'static,
+    {
+        crate::util::init_logging();
+
+        let server = Server::builder().build("127.0.0.1:0").await.unwrap();
+        let addr = server.local_addr().unwrap();
+        let handle = server.start(methods::DidRegistryMethods.into_rpc());
+
+        let client = WsClientBuilder::default()
+            .build(&format!("ws://{addr}"))
+            .await
+            .unwrap();
+
+        // cant catch_unwind b/c jsonrpsee uses tokio mpsc which is !UnwindSafe, so we wrap with a
+        // timeout.
+        // If we panic in the closure without the timeout or catch_unwind, we never return and the server will never stop, hanging our
+        // tests.
+        let result = timeout_tokio(timeout.unwrap_or(Duration::from_millis(50)), fun(client)).await;
+
+        handle.stop().unwrap();
+        handle.stopped().await;
+
+        if let Err(_) = result {
+            log::debug!("Test timed out due to panic, or running too long.");
+        }
+        result.unwrap()
+    }
+}

src/rpc/api.rs

@@ -0,0 +1,49 @@
+//! Trait Definitions for JSON-RPC
+
+use crate::types::DidDocument;
+
+use jsonrpsee::{proc_macros::rpc, types::ErrorObjectOwned};
+
+/// Decentralized Identifier JSON-RPC Interface Methods
+#[rpc(server, client, namespace = "did")]
+pub trait DidRegistry {
+    #[method(name = "resolveDid")]
+    async fn resolve_did(&self, public_key: String) -> Result<DidDocument, ErrorObjectOwned>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use async_trait::async_trait;
+    use mockall::{mock, predicate::*};
+
+    use crate::rpc::tests::with_client;
+
+    mock! {
+        pub DidRegistryMethods {}
+
+        #[async_trait]
+        impl DidRegistryServer for DidRegistryMethods {
+            async fn resolve_did(&self, _public_key: String) -> Result<DidDocument, ErrorObjectOwned>;
+        }
+    }
+
+    #[tokio::test]
+    pub async fn test_resolve_did() {
+        crate::util::init_logging();
+
+        let mut mock = MockDidRegistryMethods::new();
+        mock.expect_resolve_did().returning(|_| Ok(DidDocument));
+        // test stub
+    }
+
+    #[tokio::test]
+    pub async fn test_resolve_did_server() {
+        let _ = super::tests::with_client(None, |client| async move {
+            client.resolve_did("Hello".to_string()).await?;
+            Ok::<_, anyhow::Error>(())
+        })
+        .await;
+    }
+}

src/rpc/methods.rs

@@ -0,0 +1,20 @@
+//! Trait Implementations for DID JSON-RPC
+use super::api::*;
+use crate::types::DidDocument;
+
+use jsonrpsee::types::ErrorObjectOwned;
+
+use async_trait::async_trait;
+
+const LOG_TARGET: &str = "rpc";
+
+pub struct DidRegistryMethods;
+
+#[async_trait]
+impl DidRegistryServer for DidRegistryMethods {
+    async fn resolve_did(&self, _public_key: String) -> Result<DidDocument, ErrorObjectOwned> {
+        //TODO: Stub for resolveDid, ref: [#4](https://github.com/xmtp/didethresolver/issues/4)
+        log::debug!(target: LOG_TARGET, "resolve_did called");
+        todo!();
+    }
+}

src/types.rs

@@ -0,0 +1,7 @@
+//! Type Definitions for the DID Registry compatible with JSON
+
+use serde::{Deserialize, Serialize};
+
+// TODO: Stub
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct DidDocument;

src/util.rs

@@ -0,0 +1,25 @@
+#[cfg(test)]
+use std::sync::Once;
+use tracing_forest::ForestLayer;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Registry};
+
+#[cfg(not(test))]
+pub fn init_logging() {
+    Registry::default()
+        .with(ForestLayer::default())
+        .with(EnvFilter::from_default_env())
+        .init();
+}
+
+#[cfg(test)]
+static INIT: Once = Once::new();
+
+#[cfg(test)]
+pub fn init_logging() {
+    INIT.call_once(|| {
+        Registry::default()
+            .with(ForestLayer::default())
+            .with(EnvFilter::from_default_env())
+            .init()
+    })
+}

tests/README.md

@@ -0,0 +1 @@
+# Integration Tests