cli: init rust test

cli/src/lib.rs

@@ -871,6 +871,9 @@ fn init(
             }
             .to_owned(),
         );
+    } else if template == ProgramTemplate::RustTest {
+        cfg.scripts
+            .insert("test".to_owned(), "cargo test".to_owned());
     } else {
         cfg.scripts.insert(
             "test".to_owned(),
@@ -886,7 +889,7 @@ fn init(
     let mut localnet = BTreeMap::new();
     let program_id = rust_template::get_or_create_program_id(&rust_name);
     localnet.insert(
-        rust_name,
+        rust_name.clone(),
         ProgramDeployment {
             address: program_id,
             path: None,
@@ -916,7 +919,7 @@ fn init(
     if solidity {
         solidity_template::create_program(&project_name)?;
     } else {
-        rust_template::create_program(&project_name, template)?;
+        rust_template::create_program(&project_name, template, &program_id.to_string())?;
     }
 
     // Build the test suite.
@@ -1039,16 +1042,17 @@ fn new(
                     )?;
                 }
 
+                let program_id = rust_template::get_or_create_program_id(&name);
                 if solidity {
                     solidity_template::create_program(&name)?;
                 } else {
-                    rust_template::create_program(&name, template)?;
+                    rust_template::create_program(&name, template, &program_id.to_string())?;
                 }
 
                 programs.insert(
                     name.clone(),
                     ProgramDeployment {
-                        address: rust_template::get_or_create_program_id(&name),
+                        address: program_id,
                         path: None,
                         idl: None,
                     },

cli/src/rust_template.rs

@@ -1,5 +1,4 @@
-use crate::VERSION;
-use crate::{config::ProgramWorkspace, create_files, Files};
+use crate::{config::ProgramWorkspace, create_files, Files, VERSION};
 use anchor_syn::idl::types::Idl;
 use anyhow::Result;
 use clap::{Parser, ValueEnum};
@@ -19,20 +18,39 @@ pub enum ProgramTemplate {
     Single,
     /// Program with multiple files for instructions, state...
     Multiple,
+    /// Generate template for Rust unit-test
+    RustTest,
 }
 
 /// Create a program from the given name and template.
-pub fn create_program(name: &str, template: ProgramTemplate) -> Result<()> {
+pub fn create_program(name: &str, template: ProgramTemplate, program_id: &str) -> Result<()> {
     let program_path = Path::new("programs").join(name);
+    let tests = if template == ProgramTemplate::RustTest {
+        "tests"
+    } else {
+        ""
+    };
     let common_files = vec![
-        ("Cargo.toml".into(), workspace_manifest().into()),
+        ("Cargo.toml".into(), workspace_manifest(tests)),
         (program_path.join("Cargo.toml"), cargo_toml(name)),
         (program_path.join("Xargo.toml"), xargo_toml().into()),
     ];
 
     let template_files = match template {
         ProgramTemplate::Single => create_program_template_single(name, &program_path),
         ProgramTemplate::Multiple => create_program_template_multiple(name, &program_path),
+        ProgramTemplate::RustTest => {
+            let mut files = create_program_template_single(name, &program_path);
+            let tests_path = Path::new("tests");
+            files.extend(vec![(
+                tests_path.join("Cargo.toml"),
+                tests_cargo_toml(name),
+            )]);
+            files.extend(create_program_template_rust_test(
+                name, tests_path, program_id,
+            ));
+            files
+        }
     };
 
     create_files(&[common_files, template_files].concat())
@@ -144,10 +162,61 @@ pub fn handler(ctx: Context<Initialize>) -> Result<()> {
     ]
 }
 
-const fn workspace_manifest() -> &'static str {
-    r#"[workspace]
+/// Generate template for Rust unit-test
+fn create_program_template_rust_test(name: &str, tests_path: &Path, program_id: &str) -> Files {
+    let src_path = tests_path.join("src");
+    vec![
+        (
+            src_path.join("lib.rs"),
+            r#"#[cfg(test)]
+mod test_initialize;
+"#
+            .into(),
+        ),
+        (
+            src_path.join("test_initialize.rs"),
+            format!(
+                r#"use std::str::FromStr;
+
+use anchor_client::{{
+    solana_sdk::{{
+        commitment_config::CommitmentConfig, pubkey::Pubkey, signature::read_keypair_file,
+    }},
+    Client, Cluster,
+}};
+
+#[test]
+fn test_initialize() {{
+    let program_id = "{0}";
+    let anchor_wallet = std::env::var("ANCHOR_WALLET").expect("set ANCHOR_WALLET");
+    let payer = read_keypair_file(&anchor_wallet).expect("");
+
+    let client = Client::new_with_options(Cluster::Localnet, &payer, CommitmentConfig::confirmed());
+    let program_id = Pubkey::from_str(program_id).expect("parse program_id to Pubkey");
+    let program = client.program(program_id).expect("");
+
+    let tx = program
+        .request()
+        .accounts({1}::accounts::Initialize {{}})
+        .args({1}::instruction::Initialize {{}})
+        .send()
+        .expect("");
+
+    println!("Your transaction signature {{}}", tx);
+}}
+"#,
+                program_id, name,
+            ),
+        ),
+    ]
+}
+
+fn workspace_manifest(tests: &str) -> String {
+    format!(
+        r#"[workspace]
 members = [
-    "programs/*"
+    "programs/*",
+    "{}"
 ]
 resolver = "2"
 
@@ -159,7 +228,9 @@ codegen-units = 1
 opt-level = 3
 incremental = false
 codegen-units = 1
-"#
+"#,
+        tests
+    )
 }
 
 fn cargo_toml(name: &str) -> String {
@@ -606,3 +677,19 @@ anchor.workspace.{} = new anchor.Program({}, new PublicKey("{}"), provider);
 
     Ok(eval_string)
 }
+
+pub fn tests_cargo_toml(name: &str) -> String {
+    format!(
+        r#"[package]
+name = "tests"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2021"
+
+[dependencies]
+anchor-client = "{0}"
+{1} = {{ version = "0.1.0", path = "../programs/{1}" }}
+"#,
+        VERSION, name,
+    )
+}