feat: add --dry-run option, add -M for multithread

Cargo.lock

@@ -815,7 +815,7 @@ checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
 [[package]]
 name = "postwoman"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "base64",
  "chrono",

src/main.rs

@@ -2,10 +2,11 @@ mod model;
 mod errors;
 mod ext;
 
-use std::{collections::HashMap, str::FromStr};
+use std::str::FromStr;
 
 use clap::{Parser, Subcommand};
 
+use indexmap::IndexMap;
 pub use model::PostWomanCollection;
 pub use errors::PostWomanError;
 
@@ -24,7 +25,7 @@ struct PostWomanArgs {
 	action: Option<PostWomanActions>,
 
 	/// start a multi-thread runtime, with multiple worker threads
-	#[arg(long, default_value_t = false)]
+	#[arg(short = 'M', long, default_value_t = false)]
 	multi_threaded: bool,
 }
 
@@ -42,6 +43,10 @@ pub enum PostWomanActions {
 		/// force debug extractor on all routes
 		#[arg(long, default_value_t = false)]
 		debug: bool,
+
+		/// print matched routes but don't perform requests
+		#[arg(long, default_value_t = false)]
+		dry_run: bool,
 	},
 
 	/// show all registered routes in current collection
@@ -66,7 +71,7 @@ fn main() {
 		}
 	}
 
-	let mut collections = HashMap::new();
+	let mut collections = IndexMap::new();
 
 	if !load_collections(&mut collections, args.collection.clone()) {
 		return;
@@ -104,7 +109,7 @@ fn main() {
 	}
 }
 
-fn load_collections(store: &mut HashMap<String, PostWomanCollection>, mut path: std::path::PathBuf) -> bool {
+fn load_collections(store: &mut IndexMap<String, PostWomanCollection>, mut path: std::path::PathBuf) -> bool {
 	let collection_raw = match std::fs::read_to_string(&path) {
 		Ok(x) => x,
 		Err(e) => {
@@ -122,6 +127,7 @@ fn load_collections(store: &mut HashMap<String, PostWomanCollection>, mut path:
 	};
 
 	let name = path.to_string_lossy().to_string();
+	let mut to_include = Vec::new();
 
 	if let Some(ref includes) = collection.include {
 		path.pop();
@@ -129,14 +135,18 @@ fn load_collections(store: &mut HashMap<String, PostWomanCollection>, mut path:
 			let mut base = path.clone();
 			let new = std::path::PathBuf::from_str(include).expect("infallible");
 			base.push(new);
-			if !load_collections(store, base) {
+			to_include.push(base);
-				return false;
-			}
 		}
 	}
 
 	store.insert(name, collection);
 
+	for base in to_include {
+		if !load_collections(store, base) {
+			return false;
+		}
+	}
+
 	true
 }
 
@@ -179,7 +189,7 @@ async fn run_postwoman(args: &PostWomanArgs, namespace: String, collection: Post
 
 			println!();
 		},
-		PostWomanActions::Run { query, parallel, debug  } => {
+		PostWomanActions::Run { query, parallel, debug, dry_run  } => {
 			// this is always safe to compile because we tested it beforehand
 			let pattern = regex::Regex::new(query).expect("tested it before and still failed here???");
 			let client = std::sync::Arc::new(collection.client.unwrap_or_default());
@@ -190,16 +200,21 @@ async fn run_postwoman(args: &PostWomanArgs, namespace: String, collection: Post
 					let _client = client.clone();
 					let _env = env.clone();
 					let _endpoint = endpoint.clone();
+					let _dry_run = *dry_run;
 					let _name = name.clone();
 					let _namespace = namespace.clone();
 					let task = async move {
 						let before = chrono::Local::now();
 						eprintln!(" : [{}] {_namespace}::{_name} \tsending request...", before.format(TIMESTAMP_FMT));
-						let res = _endpoint
+						if _dry_run {
-							.fill(&_env)
+							(Ok("".to_string()), _namespace, _name, before)
-							.execute(&_client)
+						} else {
-							.await;
+							let res = _endpoint
-						(res, _namespace, _name, before)
+								.fill(&_env)
+								.execute(&_client)
+								.await;
+							(res, _namespace, _name, before)
+						}
 					};
 					if *parallel {
 						pool.spawn(task);