Introduce Context struct

src/commands/apply.rs

@@ -2,14 +2,16 @@ use std::process::exit;
 
 use serde_json::Value;
 
+use crate::context::Context;
+
 use super::plan::PlanCommand;
 
 pub struct ApplyCommand;
 
 impl ApplyCommand {
-    pub async fn run(force: &bool, config: &Value) {
+    pub async fn run(context: &Context, force: &bool, config: &Value) {
         if !force {
-            PlanCommand::run(config).await;
+            PlanCommand::run(context, config).await;
 
             print!(
                 r#"

src/commands/export.rs

@@ -1,7 +1,14 @@
+use crate::context::Context;
+
 pub struct ExportCommand;
 
 impl ExportCommand {
-    pub async fn run(config: &str, sfn_arn: &str, schedule_arn: &Option<String>) {
+    pub async fn run(
+        _context: &Context,
+        config: &str,
+        sfn_arn: &str,
+        schedule_arn: &Option<String>,
+    ) {
         println!("export called with");
         println!("- export path: {}", config);
         println!("- target sfn arn: {}", sfn_arn);

src/commands/plan.rs

@@ -1,9 +1,11 @@
 use serde_json::Value;
 
+use crate::context::Context;
+
 pub struct PlanCommand;
 
 impl PlanCommand {
-    pub async fn run(config: &Value) {
+    pub async fn run(_context: &Context, config: &Value) {
         // read config
         // fetch resource from aws api
         // diff

src/context.rs

@@ -0,0 +1,44 @@
+use crate::scheduler_client::Scheduler;
+use crate::sfn_client::Sfn;
+
+pub struct Context {
+    pub sfn_client: Sfn,
+    pub scheduler_client: Scheduler,
+}
+
+impl Context {
+    pub fn new(sfn_client: Sfn, scheduler_client: Scheduler) -> Self {
+        Self {
+            sfn_client,
+            scheduler_client,
+        }
+    }
+
+    #[cfg(not(test))]
+    pub async fn async_default() -> Self {
+        use aws_config::BehaviorVersion;
+
+        use crate::{scheduler_client, sfn_client};
+
+        let aws_config = aws_config::load_defaults(BehaviorVersion::latest()).await;
+        let sfn_client = sfn_client::Sfn::new(aws_sdk_sfn::Client::new(&aws_config));
+        let scheduler_client =
+            scheduler_client::Scheduler::new(aws_sdk_scheduler::Client::new(&aws_config));
+
+        Self {
+            sfn_client,
+            scheduler_client,
+        }
+    }
+
+    #[cfg(test)]
+    pub async fn async_default() -> Self {
+        use crate::scheduler_client::MockSchedulerImpl;
+        use crate::sfn_client::MockSfnImpl;
+
+        Self {
+            sfn_client: MockSfnImpl::default(),
+            scheduler_client: MockSchedulerImpl::default(),
+        }
+    }
+}

src/lib.rs

@@ -1,5 +1,6 @@
 pub mod cli;
 pub mod commands;
+pub mod context;
 pub mod jsonnet_evaluator;
 pub mod scheduler_client;
 pub mod sfn_client;

src/main.rs

@@ -4,6 +4,7 @@ use fubura::cli::{Cli, Commands};
 use fubura::commands::apply::ApplyCommand;
 use fubura::commands::export::ExportCommand;
 use fubura::commands::plan::PlanCommand;
+use fubura::context::Context;
 use fubura::jsonnet_evaluator;
 
 #[tokio::main]
@@ -17,20 +18,24 @@ async fn main() {
             ext_str,
         } => {
             let config = jsonnet_evaluator::eval(config, ext_str).unwrap();
+            let context = Context::async_default().await;
 
-            ApplyCommand::run(force, &config).await;
+            ApplyCommand::run(&context, force, &config).await;
         }
         Commands::Plan { config, ext_str } => {
             let config = jsonnet_evaluator::eval(config, ext_str).unwrap();
+            let context = Context::async_default().await;
 
-            PlanCommand::run(&config).await;
+            PlanCommand::run(&context, &config).await;
         }
         Commands::Export {
             config,
             sfn_arn,
             schedule_arn,
         } => {
-            ExportCommand::run(config, sfn_arn, schedule_arn).await;
+            let context = Context::async_default().await;
+
+            ExportCommand::run(&context, config, sfn_arn, schedule_arn).await;
         }
     }
 }