feat: add agent tests

agent/Cargo.toml

@@ -31,4 +31,4 @@ name = "agent_lib"
 path = "lib/src/lib.rs"
 
 [dev-dependencies]
-rand = "0.8.5"
+tempfile = "3.8.1"

agent/lib/src/api/client.rs

@@ -5,16 +5,18 @@ use log::{error, info, trace};
 
 use crate::api::grpc_definitions::{register_response::Response, RegisterRequest};
 
-use super::grpc_definitions::{
-    lambdo_api_service_client::LambdoApiServiceClient, Code, StatusMessage,
+use super::{
+    grpc_definitions::{lambdo_api_service_client::LambdoApiServiceClient, Code, StatusMessage},
+    ClientTrait, SelfCreatingClientTrait,
 };
 
 pub struct Client {
     client: LambdoApiServiceClient<tonic::transport::Channel>,
 }
 
-impl Client {
-    pub async fn new(gprc_host: IpAddr, port: u16) -> Self {
+#[tonic::async_trait]
+impl SelfCreatingClientTrait for Client {
+    async fn new(gprc_host: IpAddr, port: u16) -> Self {
         info!("Connecting to gRPC server at {}:{}", gprc_host, port);
 
         let mut counter = 0;
@@ -34,8 +36,11 @@ impl Client {
 
         panic!("Failed to connect to gRPC server");
     }
+}
 
-    pub async fn register(&mut self, port: u16) -> Result<String> {
+#[tonic::async_trait]
+impl ClientTrait for Client {
+    async fn register(&mut self, port: u16) -> Result<String> {
         info!("Registering to lambdo..");
         let register_response = self
             .client
@@ -49,7 +54,7 @@ impl Client {
         }
     }
 
-    pub async fn status(&mut self, id: String, code: Code) -> Result<()> {
+    async fn status(&mut self, id: String, code: Code) -> Result<()> {
         self.client
             .status(StatusMessage {
                 id,

agent/lib/src/api/mod.rs

@@ -1,4 +1,24 @@
+use std::net::IpAddr;
+
+use anyhow::Result;
+use grpc_definitions::Code;
+
 pub mod client;
 #[rustfmt::skip]
 pub mod grpc_definitions;
 pub mod server;
+
+/// Client trait
+/// This trait is used to abstract the gRPC client
+#[tonic::async_trait]
+pub trait ClientTrait: Send + Sync {
+    async fn status(&mut self, id: String, code: Code) -> Result<()>;
+    async fn register(&mut self, port: u16) -> Result<String>;
+}
+
+/// SelfCreatingClientTrait trait
+/// This trait is used to abstract the gRPC client creation
+#[tonic::async_trait]
+pub trait SelfCreatingClientTrait: ClientTrait {
+    async fn new(grpc_host: IpAddr, port: u16) -> Self;
+}

agent/lib/src/api/server.rs

@@ -4,32 +4,34 @@ use log::{debug, error, info, trace};
 use tokio::sync::Mutex;
 use tonic::{Request, Response, Status};
 
-use crate::{config::AgentConfig, runner_engine};
+use crate::{api::ClientTrait, config::AgentConfig, runner_engine};
 
 use super::{
-    client::Client,
     grpc_definitions::{
         lambdo_agent_service_server::LambdoAgentService, Empty, ExecuteRequest, ExecuteResponse,
         StatusMessage,
     },
+    SelfCreatingClientTrait,
 };
 
 pub struct LambdoAgentServer {
     pub config: AgentConfig,
-    pub client: Arc<Mutex<Client>>,
+    pub client: Arc<Mutex<Box<dyn ClientTrait>>>,
     pub id: String,
 }
 
 impl LambdoAgentServer {
-    pub async fn new(config: AgentConfig) -> Self {
+    pub async fn new<C: ClientTrait + SelfCreatingClientTrait + 'static>(
+        config: AgentConfig,
+    ) -> Self {
         let grpc_remote_host = IpAddr::from_str(&config.grpc.remote_host).unwrap_or_else(|e| {
             error!("Invalid IP address: {}", config.grpc.remote_host);
             panic!("{}", e.to_string())
         });
         trace!("gRPC remote host: {}", grpc_remote_host);
 
         trace!("Creating gRPC client..");
-        let mut client = Client::new(grpc_remote_host, config.grpc.remote_port).await;
+        let mut client = C::new(grpc_remote_host, config.grpc.remote_port).await;
 
         trace!("Registering to gRPC server..");
         let id = {
@@ -38,7 +40,7 @@ impl LambdoAgentServer {
                 match client.register(config.grpc.local_port).await {
                     Ok(id) => break id,
                     Err(e) => {
-                        error!("Failed to register to gRPC server, {} try: {}", counter, e);
+                        error!("Failed to rese provide us with your discord handle, after joining our servergister to gRPC server, {} try: {}", counter, e);
                         counter += 1;
                         if counter >= 10 {
                             panic!("Failed to register to gRPC server");
@@ -63,7 +65,7 @@ impl LambdoAgentServer {
 
         Self {
             config,
-            client: Arc::new(Mutex::new(client)),
+            client: Arc::new(Mutex::new(Box::new(client))),
             id,
         }
     }
@@ -84,7 +86,8 @@ impl LambdoAgentService for LambdoAgentServer {
         let request = request.into_inner();
         debug!("Received request: {:?}", request);
 
-        let mut runner_engine = runner_engine::service::RunnerEngine::new(request);
+        let mut runner_engine =
+            runner_engine::service::RunnerEngine::new(request, &self.config.workspace_path);
         let mut self_client = self.client.lock().await;
 
         if let Err(e) = runner_engine.create_workspace() {
@@ -122,3 +125,106 @@ impl LambdoAgentService for LambdoAgentServer {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::super::grpc_definitions::Code;
+    use crate::{
+        api::{
+            grpc_definitions::{
+                lambdo_agent_service_server::LambdoAgentService, Empty, ExecuteRequest,
+                ExecuteRequestStep,
+            },
+            server::LambdoAgentServer,
+            ClientTrait, SelfCreatingClientTrait,
+        },
+        config::{AgentConfig, GRPCConfig},
+    };
+    use anyhow::Result;
+    use tonic::Request;
+
+    struct MockClient;
+
+    #[tonic::async_trait]
+    impl ClientTrait for MockClient {
+        async fn register(&mut self, _local_port: u16) -> Result<String> {
+            Ok("test".to_string())
+        }
+
+        async fn status(&mut self, _id: String, _code: Code) -> Result<()> {
+            Ok(())
+        }
+    }
+
+    #[tonic::async_trait]
+    impl SelfCreatingClientTrait for MockClient {
+        async fn new(_grpc_host: std::net::IpAddr, _port: u16) -> Self {
+            MockClient
+        }
+    }
+
+    #[tokio::test]
+    async fn status_unimplemented() {
+        let config = AgentConfig {
+            apiVersion: "lambdo.io/v1alpha1".to_string(),
+            kind: "AgentConfig".to_string(),
+            grpc: GRPCConfig {
+                remote_port: 50051,
+                remote_host: "127.0.0.1".to_string(),
+                local_host: "127.0.0.1".to_string(),
+                local_port: 50051,
+            },
+            workspace_path: tempfile::tempdir()
+                .unwrap()
+                .into_path()
+                .to_str()
+                .unwrap()
+                .to_string(),
+        };
+
+        let server = LambdoAgentServer::new::<MockClient>(config).await;
+        let status = server.status(Request::new(Empty {})).await;
+
+        assert!(status.is_err());
+    }
+
+    #[tokio::test]
+    async fn execute_works() {
+        let config = AgentConfig {
+            apiVersion: "lambdo.io/v1alpha1".to_string(),
+            kind: "AgentConfig".to_string(),
+            grpc: GRPCConfig {
+                remote_port: 50051,
+                remote_host: "127.0.0.1".to_string(),
+                local_host: "127.0.0.1".to_string(),
+                local_port: 50051,
+            },
+            workspace_path: tempfile::tempdir()
+                .unwrap()
+                .into_path()
+                .to_str()
+                .unwrap()
+                .to_string(),
+        };
+
+        let server = LambdoAgentServer::new::<MockClient>(config).await;
+        let execute = server
+            .execute(Request::new(ExecuteRequest {
+                id: "test".to_string(),
+                files: vec![],
+                steps: vec![ExecuteRequestStep {
+                    command: "echo -n 'This is stdout' && echo -n 'This is stderr' >&2 && exit 1"
+                        .to_string(),
+                    enable_output: true,
+                }],
+            }))
+            .await;
+
+        assert!(execute.is_ok());
+
+        let execution_recap = execute.unwrap().into_inner();
+
+        assert_eq!(execution_recap.clone().steps[0].stdout, "This is stdout");
+        assert_eq!(execution_recap.steps[0].stderr, "This is stderr");
+    }
+}

agent/lib/src/config.rs

@@ -15,6 +15,10 @@ const fn default_local_port() -> u16 {
     0
 }
 
+fn default_workspace_path() -> String {
+    std::env::temp_dir().to_str().unwrap().to_string()
+}
+
 #[derive(Error, Debug)]
 pub enum AgentConfigError {
     #[error("cannot load config file")]
@@ -37,6 +41,9 @@ pub struct AgentConfig {
     /// The gRPC configuration
     #[serde(default = "default_grpc")]
     pub grpc: GRPCConfig,
+    /// The workspace where the agent will store the files of Requests and their resulting files
+    #[serde(default = "default_workspace_path")]
+    pub workspace_path: String,
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]