Feat : job handler tests

.env.test

@@ -0,0 +1,24 @@
+##### AWS config #####
+
+AWS_ACCESS_KEY_ID="AWS_ACCESS_KEY_ID"
+AWS_SECRET_ACCESS_KEY="AWS_SECRET_ACCESS_KEY"
+AWS_S3_BUCKET_NAME="madara-orchestrator-test-bucket"
+AWS_S3_BUCKET_REGION="us-east-1"
+AWS_ENDPOINT_URL="http://localhost.localstack.cloud:4566"
+
+##### On chain config #####
+
+MADARA_RPC_URL="http://localhost:3000"
+ETHEREUM_RPC_URL="http://localhost:3001"
+MEMORY_PAGES_CONTRACT_ADDRESS="0x000000000000000000000000000000000001dead"
+PRIVATE_KEY="0xdead"
+ETHEREUM_PRIVATE_KEY="0x000000000000000000000000000000000000000000000000000000000000beef"
+STARKNET_SOLIDITY_CORE_CONTRACT_ADDRESS="0x000000000000000000000000000000000002dead"
+
+##### Config URLs #####
+
+DA_LAYER="ethereum"
+PROVER_SERVICE="sharp"
+SETTLEMENT_LAYER="ethereum"
+DATA_STORAGE="s3"
+MONGODB_CONNECTION_STRING="mongodb://localhost:27017"

.github/workflows/coverage.yml

@@ -10,6 +10,21 @@ jobs:
     # sadly, for now we have to "rebuild" for the coverage
     runs-on: ubuntu-latest
 
+    services:
+      localstack:
+        image: localstack/localstack
+        env:
+          SERVICES: s3, sqs
+          DEFAULT_REGION: us-east-1
+          AWS_ACCESS_KEY_ID: "AWS_ACCESS_KEY_ID"
+          AWS_SECRET_ACCESS_KEY: "AWS_SECRET_ACCESS_KEY"
+        ports:
+          - 4566:4566
+      mongodb:
+        image: mongo:latest
+        ports:
+          - 27017:27017
+
     steps:
       - uses: actions/checkout@v3
 

CHANGELOG.md

@@ -9,7 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - Function to calculate the kzg proof of x_0.
 - Tests for updating the state.
 - Function to update the state and publish blob on ethereum in state update job.
-- Added basic rust-toolchain support.
+- Tests for job handlers in orchestrator/src/jobs/mod.rs.
 
 ## Changed
 

Cargo.toml

@@ -87,4 +87,4 @@ utils = { path = "crates/utils" }
 prover-client-interface = { path = "crates/prover-services/prover-client-interface" }
 gps-fact-checker = { path = "crates/prover-services/gps-fact-checker" }
 sharp-service = { path = "crates/prover-services/sharp-service" }
-orchestrator = { path = "crates/orchestrator" }
+orchestrator = { path = "crates/orchestrator" }

crates/da-clients/ethereum/src/config.rs

@@ -1,6 +1,8 @@
 use std::str::FromStr;
 
-use alloy::{network::Ethereum, providers::ProviderBuilder, rpc::client::RpcClient};
+use alloy::network::Ethereum;
+use alloy::providers::ProviderBuilder;
+use alloy::rpc::client::RpcClient;
 use async_trait::async_trait;
 use da_client_interface::DaConfig;
 use url::Url;

crates/da-clients/ethereum/src/lib.rs

@@ -20,8 +20,8 @@ pub struct EthereumDaClient {
 #[async_trait]
 impl DaClient for EthereumDaClient {
     async fn publish_state_diff(&self, _state_diff: Vec<Vec<u8>>, _to: &[u8; 32]) -> Result<String> {
-        // Here in case of ethereum we are not publishing the state diff because we are doing it all together in update_state job.
-        // So we don't need to send the blob here.
+        // Here in case of ethereum we are not publishing the state diff because we are doing it all
+        // together in update_state job. So we don't need to send the blob here.
         Ok("NA".to_string())
     }
 

crates/orchestrator/Cargo.toml

@@ -35,7 +35,8 @@ lazy_static = { workspace = true }
 log = "0.4.21"
 majin-blob-core = { git = "https://github.com/AbdelStark/majin-blob", branch = "main" }
 majin-blob-types = { git = "https://github.com/AbdelStark/majin-blob", branch = "main" }
-mockall = "0.12.1"
+mockall = { version = "0.13.0", features = ["nightly"] }
+mockall_double = "0.3.1"
 mongodb = { workspace = true, features = ["bson-uuid-1"], optional = true }
 num = { workspace = true }
 num-bigint = { workspace = true }

crates/orchestrator/src/config.rs

@@ -1,8 +1,5 @@
 use std::sync::Arc;
 
-use crate::data_storage::aws_s3::config::AWSS3Config;
-use crate::data_storage::aws_s3::AWSS3;
-use crate::data_storage::{DataStorage, DataStorageConfig};
 use arc_swap::{ArcSwap, Guard};
 use da_client_interface::{DaClient, DaConfig};
 use dotenvy::dotenv;
@@ -19,6 +16,9 @@ use utils::env_utils::get_env_var_or_panic;
 use utils::settings::default::DefaultSettingsProvider;
 use utils::settings::SettingsProvider;
 
+use crate::data_storage::aws_s3::config::AWSS3Config;
+use crate::data_storage::aws_s3::AWSS3;
+use crate::data_storage::{DataStorage, DataStorageConfig};
 use crate::database::mongodb::config::MongoDbConfig;
 use crate::database::mongodb::MongoDb;
 use crate::database::{Database, DatabaseConfig};
@@ -148,7 +148,7 @@ pub async fn config_force_init(config: Config) {
 }
 
 /// Builds the DA client based on the environment variable DA_LAYER
-async fn build_da_client() -> Box<dyn DaClient + Send + Sync> {
+pub async fn build_da_client() -> Box<dyn DaClient + Send + Sync> {
     match get_env_var_or_panic("DA_LAYER").as_str() {
         "ethereum" => {
             let config = EthereumDaConfig::new_from_env();
@@ -159,23 +159,25 @@ async fn build_da_client() -> Box<dyn DaClient + Send + Sync> {
 }
 
 /// Builds the prover service based on the environment variable PROVER_SERVICE
-fn build_prover_service(settings_provider: &impl SettingsProvider) -> Box<dyn ProverClient> {
+pub fn build_prover_service(settings_provider: &impl SettingsProvider) -> Box<dyn ProverClient> {
     match get_env_var_or_panic("PROVER_SERVICE").as_str() {
         "sharp" => Box::new(SharpProverService::with_settings(settings_provider)),
         _ => panic!("Unsupported prover service"),
     }
 }
 
 /// Builds the settlement client depending on the env variable SETTLEMENT_LAYER
-async fn build_settlement_client(settings_provider: &impl SettingsProvider) -> Box<dyn SettlementClient + Send + Sync> {
+pub async fn build_settlement_client(
+    settings_provider: &impl SettingsProvider,
+) -> Box<dyn SettlementClient + Send + Sync> {
     match get_env_var_or_panic("SETTLEMENT_LAYER").as_str() {
         "ethereum" => Box::new(EthereumSettlementClient::with_settings(settings_provider)),
         "starknet" => Box::new(StarknetSettlementClient::with_settings(settings_provider).await),
         _ => panic!("Unsupported Settlement layer"),
     }
 }
 
-async fn build_storage_client() -> Box<dyn DataStorage + Send + Sync> {
+pub async fn build_storage_client() -> Box<dyn DataStorage + Send + Sync> {
     match get_env_var_or_panic("DATA_STORAGE").as_str() {
         "s3" => Box::new(AWSS3::new(AWSS3Config::new_from_env()).await),
         _ => panic!("Unsupported Storage Client"),

crates/orchestrator/src/controllers/mod.rs

@@ -1,5 +1,2 @@
 /// Errors
 mod errors;
-
-/// Job controllers
-pub mod jobs_controller;

crates/orchestrator/src/data_storage/aws_s3/config.rs

@@ -12,6 +12,9 @@ pub struct AWSS3Config {
     pub s3_bucket_name: String,
     /// S3 Bucket region
     pub s3_bucket_region: String,
+    /// Endpoint url
+    #[cfg(test)]
+    pub endpoint_url: String,
 }
 
 /// Implementation of `DataStorageConfig` for `AWSS3Config`
@@ -23,6 +26,8 @@ impl DataStorageConfig for AWSS3Config {
             s3_key_secret: get_env_var_or_panic("AWS_SECRET_ACCESS_KEY"),
             s3_bucket_name: get_env_var_or_panic("AWS_S3_BUCKET_NAME"),
             s3_bucket_region: get_env_var_or_panic("AWS_S3_BUCKET_REGION"),
+            #[cfg(test)]
+            endpoint_url: get_env_var_or_panic("AWS_ENDPOINT_URL"),
         }
     }
 }

crates/orchestrator/src/data_storage/aws_s3/mod.rs

@@ -1,12 +1,13 @@
-use crate::data_storage::aws_s3::config::AWSS3Config;
-use crate::data_storage::DataStorage;
 use async_trait::async_trait;
 use aws_sdk_s3::config::{Builder, Credentials, Region};
 use aws_sdk_s3::primitives::ByteStream;
 use aws_sdk_s3::Client;
 use bytes::Bytes;
 use color_eyre::Result;
 
+use crate::data_storage::aws_s3::config::AWSS3Config;
+use crate::data_storage::DataStorage;
+
 /// Module for AWS S3 config structs and implementations
 pub mod config;
 
@@ -22,7 +23,6 @@ pub struct AWSS3 {
 impl AWSS3 {
     /// Initializes a new AWS S3 client by passing the config
     /// and returning it.
-    #[allow(dead_code)]
     pub async fn new(config: AWSS3Config) -> Self {
         // AWS cred building
         let credentials = Credentials::new(
@@ -33,7 +33,15 @@ impl AWSS3 {
             "loaded_from_custom_env",
         );
         let region = Region::new(config.s3_bucket_region.clone().to_string());
-        let conf_builder = Builder::new().region(region).credentials_provider(credentials);
+
+        #[allow(unused_mut)]
+        let mut conf_builder = Builder::new().region(region).credentials_provider(credentials).force_path_style(true);
+
+        #[cfg(test)]
+        {
+            conf_builder = conf_builder.endpoint_url(config.endpoint_url.clone().to_string());
+        }
+
         let conf = conf_builder.build();
 
         // Building AWS S3 config
@@ -69,4 +77,10 @@ impl DataStorage for AWSS3 {
 
         Ok(())
     }
+
+    #[cfg(test)]
+    async fn build_test_bucket(&self, bucket_name: &str) -> Result<()> {
+        self.client.create_bucket().bucket(bucket_name).send().await?;
+        Ok(())
+    }
 }

crates/orchestrator/src/data_storage/mod.rs

@@ -17,6 +17,8 @@ use mockall::automock;
 pub trait DataStorage: Send + Sync {
     async fn get_data(&self, key: &str) -> Result<Bytes>;
     async fn put_data(&self, data: Bytes, key: &str) -> Result<()>;
+    #[cfg(test)]
+    async fn build_test_bucket(&self, bucket_name: &str) -> Result<()>;
 }
 
 /// **DataStorageConfig** : Trait method to represent the config struct needed for

crates/orchestrator/src/data_storage/types.rs

@@ -1,6 +1,7 @@
+use std::collections::HashMap;
+
 use cairo_vm::Felt252;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 
 /// This struct represents the contract changes that will be in `StarknetOsOutput`
 /// as a vector.

crates/orchestrator/src/database/mod.rs

@@ -1,6 +1,6 @@
-use ::mongodb::bson::doc;
 use std::collections::HashMap;
 
+use ::mongodb::bson::doc;
 use async_trait::async_trait;
 use color_eyre::Result;
 use mockall::automock;