⚡️ Update init and fuzz add command so it support both file and macro…

… options, update default for init to fuzz with macro

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 incremented upon a breaking change and the patch version will be incremented for features.
 
 ## [dev] - Unreleased
+- feat/ add option to initialize Trident with Macro/File (for Snapshots) option based on preference ([179](https://github.com/Ackee-Blockchain/trident/pull/179))
 - del/remove localnet subcommand ([178](https://github.com/Ackee-Blockchain/trident/pull/178))
 - feat/create AccountsSnapshots derive macro for Snapshots creation ([#177](https://github.com/Ackee-Blockchain/trident/pull/177))
 - del/remove unnecessary fuzzing feature as trident is mainly fuzzer ([#176](https://github.com/Ackee-Blockchain/trident/pull/176))

crates/cli/src/command.rs

@@ -11,7 +11,7 @@ mod test;
 pub use test::test;
 
 mod init;
-pub use init::{init, TestsType};
+pub use init::{init, SnapshotsType, TestsType};
 
 mod clean;
 pub use clean::clean;

crates/cli/src/command/build.rs

@@ -22,6 +22,6 @@ pub async fn build(root: Option<String>) {
             }
         }
     };
-    let mut generator: TestGenerator = TestGenerator::new_with_root(root);
+    let mut generator: TestGenerator = TestGenerator::new_with_root(root, false);
     generator.build().await?;
 }

crates/cli/src/command/fuzz.rs

@@ -6,6 +6,8 @@ use trident_client::___private::{Commander, TestGenerator};
 
 use crate::_discover;
 
+use super::SnapshotsType;
+
 pub const TRIDENT_TOML: &str = "Trident.toml";
 
 #[derive(Subcommand)]
@@ -27,7 +29,10 @@ pub enum FuzzCommand {
         crash_file_path: String,
     },
     /// Add new fuzz test. Explicit fuzz test name is not yet supported. Implicit name is fuzz_ID, where ID is automatically derived.
-    Add,
+    Add {
+        #[clap(default_value = "macro")]
+        snapshots_type: SnapshotsType,
+    },
 }
 
 #[throws]
@@ -64,10 +69,13 @@ pub async fn fuzz(root: Option<String>, subcmd: FuzzCommand) {
             commander.run_fuzzer_debug(target, crash_file_path).await?;
         }
 
-        FuzzCommand::Add => {
+        FuzzCommand::Add { snapshots_type } => {
             // generate generator with root so that we do not need to again
             // look for root within the generator
-            let mut generator = TestGenerator::new_with_root(root);
+            let mut generator = match snapshots_type {
+                SnapshotsType::Macro => TestGenerator::new_with_root(root, false),
+                SnapshotsType::File => TestGenerator::new_with_root(root, true),
+            };
             generator.add_fuzz_test().await?;
         }
     };

crates/cli/src/command/init.rs

@@ -13,17 +13,25 @@ pub enum TestsType {
     Fuzz,
     Poc,
 }
+#[derive(ValueEnum, Clone)]
+pub enum SnapshotsType {
+    Macro,
+    File,
+}
 
 #[throws]
-pub async fn init(tests_type: TestsType) {
+pub async fn init(tests_type: TestsType, snapshots_type: SnapshotsType) {
     // look for Anchor.toml
     let root = if let Some(r) = _discover(ANCHOR_TOML)? {
         r
     } else {
         bail!("It does not seem that Anchor is initialized because the Anchor.toml file was not found in any parent directory!");
     };
 
-    let mut generator: TestGenerator = TestGenerator::new_with_root(root);
+    let mut generator: TestGenerator = match snapshots_type {
+        SnapshotsType::Macro => TestGenerator::new_with_root(root, false),
+        SnapshotsType::File => TestGenerator::new_with_root(root, true),
+    };
 
     match tests_type {
         TestsType::Poc => {

crates/cli/src/lib.rs

@@ -1,7 +1,7 @@
 use anyhow::Error;
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
-use command::TestsType;
+use command::{SnapshotsType, TestsType};
 use fehler::throws;
 
 // subcommand functions to call and nested subcommands
@@ -48,8 +48,11 @@ enum Command {
     /// Initialize test environment
     Init {
         /// Specifies the types of tests for which the frameworks should be initialized.
-        #[clap(default_value = "both")]
+        #[clap(default_value = "fuzz")]
         tests_type: TestsType,
+        /// Specifies type of Accounts Snapshots, i.e used derive macro or generated file
+        #[clap(default_value = "macro")]
+        snapshots_type: SnapshotsType,
     },
     /// Removes target contents except for KeyPair and removes hfuzz_target folder
     Clean,
@@ -64,7 +67,10 @@ pub async fn start() {
         Command::KeyPair { subcmd } => command::keypair(subcmd)?,
         Command::Test { root } => command::test(root).await?,
         Command::Fuzz { root, subcmd } => command::fuzz(root, subcmd).await?,
-        Command::Init { tests_type } => command::init(tests_type).await?,
+        Command::Init {
+            tests_type,
+            snapshots_type,
+        } => command::init(tests_type, snapshots_type).await?,
         Command::Clean => command::clean().await?,
     }
 }

crates/client/src/source_code_generators/fuzzer_generator.rs

@@ -214,7 +214,7 @@ pub fn generate_source_code(programs_data: &[ProgramData]) -> String {
             let fuzzer_module: syn::ItemMod = parse_quote! {
                 pub mod #fuzz_instructions_module_name {
                     use trident_client::fuzzing::*;
-                    use crate::accounts_snapshots::*;
+                    // use crate::accounts_snapshots::*;
 
                     #[derive(Arbitrary, DisplayIx, FuzzTestExecutor, FuzzDeserialize)]
                     pub enum FuzzInstruction {

crates/client/src/templates/trident-tests/test_fuzz.rs

@@ -1,5 +1,4 @@
 use trident_client::fuzzing::*;
-mod accounts_snapshots;
 mod fuzz_instructions;
 
 const PROGRAM_NAME: &str = "###PROGRAM_NAME###";

crates/client/src/test_generator.rs

@@ -120,10 +120,11 @@ pub struct TestGenerator {
     pub programs_data: Vec<ProgramData>,
     pub packages: Vec<Package>,
     pub use_tokens: Vec<ItemUse>,
+    pub with_snapshot_file: bool,
 }
 impl Default for TestGenerator {
     fn default() -> Self {
-        Self::new()
+        Self::new(false)
     }
 }
 
@@ -133,12 +134,13 @@ impl TestGenerator {
     /// # Returns
     ///
     /// A new `TestGenerator` instance.
-    pub fn new() -> Self {
+    pub fn new(with_snapshot_file: bool) -> Self {
         Self {
             root: Path::new("../../").to_path_buf(),
             programs_data: Vec::default(),
             packages: Vec::default(),
             use_tokens: Vec::default(),
+            with_snapshot_file,
         }
     }
     /// Creates a new instance of `TestGenerator` with a specified root directory.
@@ -150,12 +152,13 @@ impl TestGenerator {
     /// # Returns
     ///
     /// A new `TestGenerator` instance with the specified root directory.
-    pub fn new_with_root(root: String) -> Self {
+    pub fn new_with_root(root: String, with_snapshot_file: bool) -> Self {
         Self {
             root: Path::new(&root).to_path_buf(),
             programs_data: Vec::default(),
             packages: Vec::default(),
             use_tokens: Vec::default(),
+            with_snapshot_file,
         }
     }
     /// Generates both proof of concept (POC) and fuzz tests along with the necessary setup.
@@ -420,17 +423,6 @@ impl TestGenerator {
     /// If not present add fuzz_tests into the workspace virtual manifest as member
     #[throws]
     pub async fn add_new_fuzz_test(&self) {
-        let program_name = if !&self.programs_data.is_empty() {
-            &self
-                .programs_data
-                .first()
-                .unwrap()
-                .program_idl
-                .name
-                .snake_case
-        } else {
-            throw!(Error::NoProgramsFound)
-        };
         let fuzz_dir_path =
             construct_path!(self.root, TESTS_WORKSPACE_DIRECTORY, FUZZ_TEST_DIRECTORY);
         let fuzz_tests_manifest_path = construct_path!(fuzz_dir_path, CARGO_TOML);
@@ -473,6 +465,48 @@ impl TestGenerator {
 
         self.create_directory(&new_fuzz_test_dir).await?;
 
+        // create fuzz file
+        self.initialize_fuzz(&new_fuzz_test_dir).await?;
+
+        // create fuzz instructions file
+        self.initialize_fuzz_instructions(&new_fuzz_test_dir)
+            .await?;
+
+        // create accounts_snapshots file
+        if self.with_snapshot_file {
+            self.initialize_fuzz_snapshots(&new_fuzz_test_dir).await?;
+        }
+
+        let cargo_toml_content =
+            load_template!("/src/templates/trident-tests/Cargo_fuzz.toml.tmpl");
+
+        self.create_file(&fuzz_tests_manifest_path, cargo_toml_content)
+            .await?;
+
+        self.add_bin_target(&fuzz_tests_manifest_path, &new_fuzz_test, &new_bin_target)
+            .await?;
+        self.add_program_dependencies(&fuzz_dir_path, "dependencies", None)
+            .await?;
+
+        self.add_workspace_member(&format!(
+            "{TESTS_WORKSPACE_DIRECTORY}/{FUZZ_TEST_DIRECTORY}",
+        ))
+        .await?;
+    }
+
+    #[throws]
+    pub async fn initialize_fuzz(&self, new_fuzz_test_dir: &Path) {
+        let program_name = if !&self.programs_data.is_empty() {
+            &self
+                .programs_data
+                .first()
+                .unwrap()
+                .program_idl
+                .name
+                .snake_case
+        } else {
+            throw!(Error::NoProgramsFound)
+        };
         let fuzz_test_path = new_fuzz_test_dir.join(FUZZ_TEST);
 
         let fuzz_test_content = load_template!("/src/templates/trident-tests/test_fuzz.rs");
@@ -489,39 +523,27 @@ impl TestGenerator {
 
         self.create_file(&fuzz_test_path, &fuzz_test_content)
             .await?;
+    }
 
-        // create fuzz instructions file
+    #[throws]
+    pub async fn initialize_fuzz_instructions(&self, new_fuzz_test_dir: &Path) {
         let fuzz_instructions_path = new_fuzz_test_dir.join(FUZZ_INSTRUCTIONS_FILE_NAME);
         let program_fuzzer = fuzzer_generator::generate_source_code(&self.programs_data);
         let program_fuzzer = Commander::format_program_code(&program_fuzzer).await?;
 
         self.create_file(&fuzz_instructions_path, &program_fuzzer)
             .await?;
+    }
 
-        // // create accounts_snapshots file
+    #[throws]
+    pub async fn initialize_fuzz_snapshots(&self, new_fuzz_test_dir: &Path) {
         let accounts_snapshots_path = new_fuzz_test_dir.join(ACCOUNTS_SNAPSHOTS_FILE_NAME);
         let fuzzer_snapshots = snapshot_generator::generate_snapshots_code(&self.programs_data)
             .map_err(Error::ReadProgramCodeFailed)?;
         let fuzzer_snapshots = Commander::format_program_code(&fuzzer_snapshots).await?;
 
         self.create_file(&accounts_snapshots_path, &fuzzer_snapshots)
             .await?;
-
-        let cargo_toml_content =
-            load_template!("/src/templates/trident-tests/Cargo_fuzz.toml.tmpl");
-
-        self.create_file(&fuzz_tests_manifest_path, cargo_toml_content)
-            .await?;
-
-        self.add_bin_target(&fuzz_tests_manifest_path, &new_fuzz_test, &new_bin_target)
-            .await?;
-        self.add_program_dependencies(&fuzz_dir_path, "dependencies", None)
-            .await?;
-
-        self.add_workspace_member(&format!(
-            "{TESTS_WORKSPACE_DIRECTORY}/{FUZZ_TEST_DIRECTORY}",
-        ))
-        .await?;
     }
 
     /// Add/Update .program_client

crates/client/tests/test_data/expected_source_codes/expected_fuzz_instructions.rs

@@ -1,5 +1,4 @@
 pub mod fuzz_example3_fuzz_instructions {
-    use crate::accounts_snapshots::*;
     use trident_client::fuzzing::*;
     #[derive(Arbitrary, DisplayIx, FuzzTestExecutor, FuzzDeserialize)]
     pub enum FuzzInstruction {