refactor; move tgests to own file everywhere

Author: davidatsurge

macros_impl/src/zwang_router/path.rs

@@ -127,14 +127,4 @@ fn construct_typed_path(parts: &[Part], cur_idx: usize) -> proc_macro2::TokenStr
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::zwang_url;
-
-    #[test]
-    fn basic_url_construction() {
-        let expr: syn::LitStr = parse_quote! { "/owner_name=hi/repo_name=hello/issues/new" };
-        let url = zwang_url(expr);
-        println!("{}", url);
-    }
-}
+mod tests;

macros_impl/src/zwang_router/path/tests.rs

@@ -0,0 +1,9 @@
+use super::*;
+use crate::zwang_url;
+
+#[test]
+fn basic_url_construction() {
+    let expr: syn::LitStr = parse_quote! { "/owner_name=hi/repo_name=hello/issues/new" };
+    let url = zwang_url(expr);
+    println!("{}", url);
+}

macros_impl/src/zwang_router/routes/main_model.rs

@@ -266,16 +266,4 @@ impl TryFrom<parsing::Part> for Parts {
 }
 
 #[cfg(test)]
-mod tests {
-    use crate::zwang_router::TEST_STR;
-
-    use super::*;
-
-    #[test]
-    fn test_converting_to_main_model_parts() -> Result<()> {
-        let parsed: parsing::Part = parse_str(TEST_STR).expect("Unable to parse routes");
-        let main_model_parts = Parts::try_from(parsed)?;
-        println!("{:#?}", main_model_parts);
-        Ok(())
-    }
-}
+mod tests;

macros_impl/src/zwang_router/routes/main_model/tests.rs

@@ -0,0 +1,11 @@
+use crate::zwang_router::TEST_STR;
+
+use super::*;
+
+#[test]
+fn test_converting_to_main_model_parts() -> Result<()> {
+    let parsed: parsing::Part = parse_str(TEST_STR).expect("Unable to parse routes");
+    let main_model_parts = Parts::try_from(parsed)?;
+    println!("{:#?}", main_model_parts);
+    Ok(())
+}

macros_impl/src/zwang_router/routes/parsing.rs

@@ -153,15 +153,4 @@ impl Parse for Part {
 }
 
 #[cfg(test)]
-mod tests {
-    use crate::zwang_router::TEST_STR;
-
-    use super::*;
-    use syn::parse_str;
-
-    #[test]
-    fn test_parse_routes_with_fallback() {
-        let parsed: Part = parse_str(TEST_STR).expect("Unable to parse routes");
-        println!("{parsed:#?}");
-    }
-}
+mod tests;

macros_impl/src/zwang_router/routes/parsing/tests.rs

@@ -0,0 +1,10 @@
+use crate::zwang_router::TEST_STR;
+
+use super::*;
+use syn::parse_str;
+
+#[test]
+fn test_parse_routes_with_fallback() {
+    let parsed: Part = parse_str(TEST_STR).expect("Unable to parse routes");
+    println!("{parsed:#?}");
+}

macros_impl/src/zwang_router/routes/write_output.rs

@@ -783,23 +783,4 @@ fn write_param_struct_construction_at_sub_part(sub_part: &main_model::Part) -> T
 }
 
 #[cfg(test)]
-mod tests {
-    use main_model::Parts;
-
-    use crate::zwang_router::{parsing, TEST_STR};
-
-    use super::*;
-
-    #[test]
-    fn test_writing_output() -> Result<()> {
-        let parsed: parsing::Part = parse_str(TEST_STR).expect("Unable to parse routes");
-        let main_model_parts = Parts::try_from(parsed)?;
-        let output = write_output(main_model_parts).unwrap().to_string();
-        // println!("\n\n{output}\n\n");
-        println!(
-            "\n\n{}\n\n",
-            prettyplease::unparse(&syn::parse_file(&output).unwrap())
-        );
-        Ok(())
-    }
-}
+mod tests;

macros_impl/src/zwang_router/routes/write_output/tests.rs

@@ -0,0 +1,18 @@
+use main_model::Parts;
+
+use crate::zwang_router::{parsing, TEST_STR};
+
+use super::*;
+
+#[test]
+fn test_writing_output() -> Result<()> {
+    let parsed: parsing::Part = parse_str(TEST_STR).expect("Unable to parse routes");
+    let main_model_parts = Parts::try_from(parsed)?;
+    let output = write_output(main_model_parts).unwrap().to_string();
+    // println!("\n\n{output}\n\n");
+    println!(
+        "\n\n{}\n\n",
+        prettyplease::unparse(&syn::parse_file(&output).unwrap())
+    );
+    Ok(())
+}

shared/src/sync_engine/websocket_updates/transport.rs

@@ -122,86 +122,4 @@ where
 }
 
 #[cfg(test)]
-pub mod tests {
-    use std::{
-        pin::Pin,
-        task::{Context, Poll},
-    };
-
-    use futures::{channel::mpsc, Sink, Stream};
-
-    use crate::endpoints::defns::api::websocket_updates::{ClientMsg, ServerMsg};
-
-    use super::TransportTrait;
-
-    pub struct MockTransportHandler {
-        send: mpsc::Sender<ServerMsg>,
-        recv: mpsc::Receiver<ClientMsg>,
-    }
-
-    pub struct MockTransport {
-        recv: mpsc::Receiver<ServerMsg>,
-        send: mpsc::Sender<ClientMsg>,
-    }
-
-    impl TransportTrait for MockTransport {
-        type TransportError = mpsc::SendError;
-    }
-
-    impl MockTransport {
-        pub fn new() -> (Self, MockTransportHandler) {
-            let (server_msg_sender, server_msg_receiver) = mpsc::channel(100);
-            let (client_msg_sender, client_msg_receiver) = mpsc::channel(100);
-
-            (
-                Self {
-                    recv: server_msg_receiver,
-                    send: client_msg_sender,
-                },
-                MockTransportHandler {
-                    send: server_msg_sender,
-                    recv: client_msg_receiver,
-                },
-            )
-        }
-    }
-
-    impl Stream for MockTransport {
-        type Item = Result<ServerMsg, mpsc::SendError>;
-
-        fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-            Pin::new(&mut self.recv)
-                .poll_next(cx)
-                .map(|opt| opt.map(Ok))
-        }
-    }
-
-    impl Sink<ClientMsg> for MockTransport {
-        type Error = mpsc::SendError;
-
-        fn poll_ready(
-            mut self: Pin<&mut Self>,
-            cx: &mut Context<'_>,
-        ) -> Poll<Result<(), Self::Error>> {
-            Pin::new(&mut self.send).poll_ready(cx)
-        }
-
-        fn start_send(mut self: Pin<&mut Self>, item: ClientMsg) -> Result<(), Self::Error> {
-            Pin::new(&mut self.send).start_send(item)
-        }
-
-        fn poll_flush(
-            mut self: Pin<&mut Self>,
-            cx: &mut Context<'_>,
-        ) -> Poll<Result<(), Self::Error>> {
-            Pin::new(&mut self.send).poll_flush(cx)
-        }
-
-        fn poll_close(
-            mut self: Pin<&mut Self>,
-            cx: &mut Context<'_>,
-        ) -> Poll<Result<(), Self::Error>> {
-            Pin::new(&mut self.send).poll_close(cx)
-        }
-    }
-}
+pub mod tests;

shared/src/sync_engine/websocket_updates/transport/tests.rs

@@ -0,0 +1,81 @@
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use futures::{channel::mpsc, Sink, Stream};
+
+use crate::endpoints::defns::api::websocket_updates::{ClientMsg, ServerMsg};
+
+use super::TransportTrait;
+
+pub struct MockTransportHandler {
+    send: mpsc::Sender<ServerMsg>,
+    recv: mpsc::Receiver<ClientMsg>,
+}
+
+pub struct MockTransport {
+    recv: mpsc::Receiver<ServerMsg>,
+    send: mpsc::Sender<ClientMsg>,
+}
+
+impl TransportTrait for MockTransport {
+    type TransportError = mpsc::SendError;
+}
+
+impl MockTransport {
+    pub fn new() -> (Self, MockTransportHandler) {
+        let (server_msg_sender, server_msg_receiver) = mpsc::channel(100);
+        let (client_msg_sender, client_msg_receiver) = mpsc::channel(100);
+
+        (
+            Self {
+                recv: server_msg_receiver,
+                send: client_msg_sender,
+            },
+            MockTransportHandler {
+                send: server_msg_sender,
+                recv: client_msg_receiver,
+            },
+        )
+    }
+}
+
+impl Stream for MockTransport {
+    type Item = Result<ServerMsg, mpsc::SendError>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Pin::new(&mut self.recv)
+            .poll_next(cx)
+            .map(|opt| opt.map(Ok))
+    }
+}
+
+impl Sink<ClientMsg> for MockTransport {
+    type Error = mpsc::SendError;
+
+    fn poll_ready(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        Pin::new(&mut self.send).poll_ready(cx)
+    }
+
+    fn start_send(mut self: Pin<&mut Self>, item: ClientMsg) -> Result<(), Self::Error> {
+        Pin::new(&mut self.send).start_send(item)
+    }
+
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        Pin::new(&mut self.send).poll_flush(cx)
+    }
+
+    fn poll_close(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        Pin::new(&mut self.send).poll_close(cx)
+    }
+}