Implement basic test for the client interface

tests/mod.rs

@@ -16,6 +16,7 @@ You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 use eagle::Protocol;
+use tokio::sync::mpsc::{self, Receiver, Sender};
 
 #[derive(Protocol)]
 enum TestProtocol {
@@ -25,23 +26,63 @@ enum TestProtocol {
     Void((), ()),
 }
 
-struct DummyServer;
-impl TestProtocolServer for DummyServer {
-    fn some_kind_of_question(&mut self, question: String) -> i32 {
-        question.len() as i32
-    }
-
-    fn addition(&mut self, a: i32, b: i32) -> i32 {
-        a + b
-    }
-
-    fn this_responds_with_a_string(&mut self, arg: i32) -> String {
-        format!("The number is {}", arg)
-    }
-
-    fn void(&mut self) {
-        println!("Void function called!")
-    }
+#[tokio::test]
+async fn main() {
+    let (qtx, qrx) = mpsc::channel(16);
+    let (atx, arx) = mpsc::channel(16);
+    let mut client = TestProtocolClient::new(qtx, arx);
+    let server = tokio::spawn(server_loop(qrx, atx));
+    let result = client.addition(2, 5).await.unwrap();
+    assert_eq!(result, 7);
+    let result = client
+        .some_kind_of_question("Hello, world!".to_string())
+        .await
+        .unwrap();
+    assert_eq!(result, "Hello, world!".len() as i32);
+    let result = client.this_responds_with_a_string(42).await.unwrap();
+    assert_eq!(result, "The number is 42");
+    client.void().await.unwrap();
+    server.abort();
 }
 
-fn main() {}
+async fn server_loop(
+    mut qrx: Receiver<(u64, __TestProtocolQuestion)>,
+    atx: Sender<(u64, __TestProtocolAnswer)>,
+) {
+    loop {
+        if let Some((nonce, q)) = qrx.recv().await {
+            match q {
+                __TestProtocolQuestion::addition((a, b)) => {
+                    atx.send((nonce, __TestProtocolAnswer::addition(a + b)))
+                        .await
+                        .unwrap();
+                }
+                __TestProtocolQuestion::some_kind_of_question(s) => {
+                    atx.send((
+                        nonce,
+                        __TestProtocolAnswer::some_kind_of_question(s.len() as i32),
+                    ))
+                    .await
+                    .unwrap();
+                }
+                __TestProtocolQuestion::this_responds_with_a_string(i) => {
+                    atx.send((
+                        nonce,
+                        __TestProtocolAnswer::this_responds_with_a_string(format!(
+                            "The number is {}",
+                            i
+                        )),
+                    ))
+                    .await
+                    .unwrap();
+                }
+                __TestProtocolQuestion::void(()) => {
+                    println!("Received void question");
+                    atx.send((nonce, __TestProtocolAnswer::void(())))
+                        .await
+                        .unwrap();
+                }
+            }
+        }
+    }
+}