add skeleton of a test for kpi-13 in orc

Author: lukasz-zet

edgeless_api/Cargo.toml

@@ -33,6 +33,7 @@ grpc_impl = [
     "dep:prost",
     "tonic-build",
 ]
+mocks = [] # used to enable mockall in edgeless_api for testing
 
 [dependencies]
 anyhow = "1.0"
@@ -53,6 +54,7 @@ tokio = { version = "1", features = ["full"], optional = true }
 toml = "0.9.8"
 tonic = { version = "0.13", features = ["_tls-any"], optional = true }
 uuid = { version = "1.3", features = ["v4", "serde"] }
+mockall = "0.14"
 
 [target.'cfg(not(target_os = "macos"))'.dependencies]
 rustls = { version = "0.23.32", features = ["ring"] }

edgeless_api/src/node_management.rs

@@ -10,6 +10,7 @@ pub enum UpdatePeersRequest {
     Clear,
 }
 
+#[cfg_attr(feature = "mocks", mockall::automock)]
 #[async_trait::async_trait]
 pub trait NodeManagementAPI: NodeManagementAPIClone + Sync + Send {
     async fn update_peers(&mut self, request: UpdatePeersRequest) -> anyhow::Result<()>;
@@ -33,3 +34,10 @@ impl Clone for Box<dyn NodeManagementAPI> {
         self.clone_box()
     }
 }
+
+#[cfg(feature = "mocks")]
+impl NodeManagementAPIClone for MockNodeManagementAPI {
+    fn clone_box(&self) -> Box<dyn NodeManagementAPI> {
+        Box::new(MockNodeManagementAPI::new())
+    }
+}

edgeless_api/src/outer/agent.rs

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: © 2023 Claudio Cicconetti <c.cicconetti@iit.cnr.it>
 // SPDX-FileCopyrightText: © 2023 Siemens AG
 // SPDX-License-Identifier: MIT
+#[cfg_attr(feature = "mocks", mockall::automock)]
 pub trait AgentAPI {
     fn function_instance_api(&mut self) -> Box<dyn crate::function_instance::FunctionInstanceAPI<edgeless_api_core::instance_id::InstanceId>>;
     fn node_management_api(&mut self) -> Box<dyn crate::node_management::NodeManagementAPI>;

edgeless_orc/Cargo.toml

@@ -49,3 +49,9 @@ serial_test = { version = "3" }
 itertools = "0.13.0"
 chrono = "0.4.38"
 rustls = { version = "0.23.29", features = ["ring"] }
+
+[dev-dependencies]
+mockall = "0.14"
+
+[target.'cfg(test)'.dependencies]
+edgeless_api = {path = "../edgeless_api", features = ["mocks"]} # enable mocks in edgeless_api for tests

edgeless_orc/src/client_desc.rs

@@ -9,6 +9,7 @@ pub struct ClientDesc {
     pub cordoned: bool,
 }
 
+#[cfg_attr(test, mockall::automock)]
 impl ClientDesc {
     pub async fn from(request: &edgeless_api::node_registration::UpdateNodeRequest) -> anyhow::Result<Self> {
         // Return immediately if the node has an invalid agent or invocation URL.

edgeless_orc/src/orchestrator_task.rs

@@ -1187,3 +1187,57 @@ impl OrchestratorTask {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_start_two_functions_then_stop_one() {
+        // channels
+        let (_tx, rx) = futures::channel::mpsc::unbounded();
+        let (subscriber_tx, _subscriber_rx) = futures::channel::mpsc::unbounded();
+        
+        // mock proxy expectations setting
+        let mut mock_proxy = crate::proxy::MockProxy::new();
+        mock_proxy.expect_update_nodes().returning(|_| ());
+        mock_proxy.expect_update_resource_providers().returning(|_| ());
+        mock_proxy.expect_update_active_instances().returning(|_| ());
+        mock_proxy.expect_update_dependency_graph().returning(|_| ());
+        mock_proxy.expect_retrieve_deploy_intents().returning(|| vec![]);
+
+        // mock AgentAPI expectations
+        let mut mock_agent_api = edgeless_api::outer::agent::MockAgentAPI::new();
+        mock_agent_api.expect_node_management_api()
+            .returning(|| {
+                let mut mock_node_mgmt_api = edgeless_api::node_management::MockNodeManagementAPI::new();
+                mock_node_mgmt_api.expect_update_peers()
+                    .returning(|_| Ok(()));
+                Box::new(mock_node_mgmt_api)
+            });
+        
+        let proxy = std::sync::Arc::new(tokio::sync::Mutex::new(mock_proxy));
+        
+        let settings = crate::EdgelessOrcBaselineSettings {
+            orchestration_strategy: crate::OrchestrationStrategy::RoundRobin,
+        };
+        
+        let mut _orchestrator = OrchestratorTask::new(rx, settings, proxy.clone(), subscriber_tx).await;
+
+        // Add three nodes
+        let node_1_id = uuid::Uuid::new_v4();
+        let client_desc = crate::client_desc::ClientDesc {
+            agent_url: "http://node1/agent".to_string(),
+            invocation_url: "http://node1".to_string(),
+            capabilities: edgeless_api::node_registration::NodeCapabilities::default(),
+            cordoned: false,
+            api: Box::new(mock_agent_api),
+        };
+        let resource_providers = vec![];
+        _orchestrator.add_node(node_1_id, client_desc, resource_providers).await;
+        // test if it works
+        assert_eq!(1, 1);
+    }
+}
+
+

edgeless_orc/src/proxy.rs

@@ -21,6 +21,7 @@ pub type NodeHealthStatuses = std::collections::HashMap<
     Vec<(chrono::DateTime<chrono::Utc>, edgeless_api::node_registration::NodeHealthStatus)>,
 >;
 
+#[cfg_attr(test, mockall::automock)]
 #[async_trait::async_trait]
 pub trait Proxy: Sync + Send {
     /// Update the info on the currently actives nodes as given.