fix tests & rm ignore on some cases

Author: erhant

compute/src/node/gossipsub.rs

@@ -147,61 +147,3 @@ impl DriaComputeNode {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::DriaComputeNodeConfig;
-    use tokio::time::sleep;
-    use tokio_util::sync::CancellationToken;
-
-    // FIXME: test is failing
-    #[tokio::test]
-    #[ignore = "run this manually"]
-    async fn test_publish_message() -> eyre::Result<()> {
-        let _ = env_logger::builder()
-            .filter_level(log::LevelFilter::Off)
-            .filter_module("dkn_compute", log::LevelFilter::Debug)
-            .filter_module("dkn_p2p", log::LevelFilter::Debug)
-            .is_test(true)
-            .try_init();
-
-        // create node
-        let cancellation = CancellationToken::new();
-        let config = DriaComputeNodeConfig::default();
-        let (mut node, p2p, _, _) = DriaComputeNode::new(config).await?;
-
-        // spawn p2p task
-        let p2p_task = tokio::spawn(async move { p2p.run().await });
-
-        // launch & wait for a while for connections
-        let run_cancellation = cancellation.clone();
-        let wait_duration = tokio::time::Duration::from_secs(20);
-        log::info!(
-            "Waiting a bit ({}ms) for peer setup.",
-            wait_duration.as_millis()
-        );
-        sleep(wait_duration).await;
-        tokio::select! {
-            _ = node.run(run_cancellation) => (),
-            _ = tokio::time::sleep(wait_duration) => cancellation.cancel(),
-        }
-        log::info!("Connected Peers:\n{:#?}", node.peers().await?);
-
-        // publish a dummy message
-        let topic = "foo";
-        let message = node.new_message("hello from the other side", topic);
-        node.subscribe(topic).await?;
-        node.publish(message).await?;
-        node.unsubscribe(topic).await?;
-
-        // close everything
-        log::info!("Shutting down node.");
-        node.p2p.shutdown().await?;
-
-        // wait for task handle
-        p2p_task.await?;
-
-        Ok(())
-    }
-}

compute/src/utils/crypto.rs

@@ -114,23 +114,4 @@ mod tests {
             "could not verify signature"
         );
     }
-
-    #[test]
-    #[ignore = "run only with profiler if wanted"]
-    fn test_memory_usage() {
-        let secret_key =
-            SecretKey::parse_slice(DUMMY_SECRET_KEY).expect("to parse private key slice");
-        let public_key = PublicKey::from_secret_key(&secret_key);
-
-        // sign the message using the secret key
-        let digest = sha256hash(MESSAGE);
-        let message = Message::parse_slice(&digest).expect("to parse message");
-        let (signature, _) = sign(&message, &secret_key);
-
-        // verify signature with context
-        for _ in 0..1_000_000 {
-            let ok = verify(&message, &signature, &public_key);
-            assert!(ok);
-        }
-    }
 }

compute/src/utils/nodes.rs

@@ -56,14 +56,19 @@ mod tests {
     use super::*;
 
     #[tokio::test]
-    #[ignore = "run this manually"]
     async fn test_refresh_dria_nodes() {
         let mut nodes = DriaNodes::new(DriaNetworkType::Community);
         refresh_dria_nodes(&mut nodes).await.unwrap();
-        println!("Community: {:#?}", nodes);
+        assert!(!nodes.bootstrap_nodes.is_empty());
+        assert!(!nodes.relay_nodes.is_empty());
+        assert!(!nodes.rpc_nodes.is_empty());
+        assert!(!nodes.rpc_peerids.is_empty());
 
         let mut nodes = DriaNodes::new(DriaNetworkType::Pro);
         refresh_dria_nodes(&mut nodes).await.unwrap();
-        println!("Pro: {:#?}", nodes);
+        assert!(!nodes.bootstrap_nodes.is_empty());
+        assert!(!nodes.relay_nodes.is_empty());
+        assert!(!nodes.rpc_nodes.is_empty());
+        assert!(!nodes.rpc_peerids.is_empty());
     }
 }

compute/src/utils/specs.rs

@@ -84,10 +84,18 @@ mod tests {
     use super::*;
 
     #[tokio::test]
-    #[ignore = "run manually"]
     async fn test_print_specs() {
         let mut spec_collector = SpecCollector::new(vec!["gpt-4o".to_string()]);
         let specs = spec_collector.collect().await;
-        println!("{}", serde_json::to_string_pretty(&specs).unwrap());
+        assert!(specs.total_mem > 0);
+        assert!(specs.free_mem > 0);
+        assert!(specs.num_cpus.is_some());
+        assert!(specs.cpu_usage > 0.0);
+        assert!(!specs.os.is_empty());
+        assert!(!specs.arch.is_empty());
+        assert!(specs.lookup.is_some());
+
+        // print optionally:
+        // println!("{}", serde_json::to_string_pretty(&specs).unwrap());
     }
 }

p2p/tests/gossipsub_test.rs

@@ -19,7 +19,7 @@ async fn test_gossipsub() -> Result<()> {
         .filter_level(log::LevelFilter::Off)
         .filter_module("gossipsub_test", log::LevelFilter::Debug)
         .filter_module("dkn_p2p", log::LevelFilter::Debug)
-        .is_test(true)
+        // .is_test(true)
         .try_init();
 
     let listen_addr = "/ip4/0.0.0.0/tcp/4001".parse()?;

workflows/src/config.rs

@@ -202,15 +202,13 @@ impl DriaWorkflowsConfig {
     }
 
     /// Check if the required compute services are running.
-    /// This has several steps:
     ///
     /// - If Ollama models are used, hardcoded models are checked locally, and for
     ///   external models, the workflow is tested with a simple task with timeout.
-    /// - If OpenAI models are used, the API key is checked and the models are tested
+    /// - If API based models are used, the API key is checked and the models are tested with a dummy request.
     ///
-    /// If both type of models are used, both services are checked.
     /// In the end, bad models are filtered out and we simply check if we are left if any valid models at all.
-    /// If not, an error is returned.
+    /// If there are no models left in the end, an error is thrown.
     pub async fn check_services(&mut self) -> Result<()> {
         log::info!("Checking configured services.");
 

workflows/tests/models_test.rs

@@ -1,13 +1,16 @@
 use dkn_workflows::{DriaWorkflowsConfig, Model, ModelProvider};
 use eyre::Result;
 
+#[inline(always)]
 fn setup() {
     // read api key from .env
     let _ = dotenvy::dotenv();
 
     // set logger
     let _ = env_logger::builder()
-        .parse_filters("none,dkn_workflows=debug")
+        .filter_level(log::LevelFilter::Off)
+        .filter_module("models_test", log::LevelFilter::Debug)
+        .filter_module("dkn_workflows", log::LevelFilter::Debug)
         .is_test(true)
         .try_init();
 }
@@ -61,6 +64,22 @@ async fn test_gemini_check() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+#[ignore = "requires OpenRouter"]
+async fn test_openrouter_check() -> Result<()> {
+    setup();
+
+    let models = vec![Model::ORDeepSeek2_5];
+    let mut model_config = DriaWorkflowsConfig::new(models);
+    model_config.check_services().await?;
+
+    assert_eq!(
+        model_config.models[0],
+        (ModelProvider::OpenRouter, Model::ORDeepSeek2_5)
+    );
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_empty() {
     assert!(DriaWorkflowsConfig::new(vec![])

workflows/tests/parse_test.rs

@@ -1,7 +1,7 @@
 use dkn_workflows::Workflow;
 
 #[test]
-fn test_parse_example() -> eyre::Result<()> {
+fn test_parse_example() {
     let object = serde_json::json!({
        "config":{
           "max_steps":50,
@@ -70,13 +70,7 @@ fn test_parse_example() -> eyre::Result<()> {
                 }
              ],
              "schema":null,
-             "inputs":[
-
-             ],
              "operator":"end",
-             "outputs":[
-
-             ]
           }
        ],
        "steps":[
@@ -99,7 +93,8 @@ fn test_parse_example() -> eyre::Result<()> {
        }
     });
 
-    serde_json::from_value::<Workflow>(object)?;
-
-    Ok(())
+    assert!(
+        serde_json::from_value::<Workflow>(object).is_ok(),
+        "could not parse"
+    );
 }