inital commit, which is clearly not initial

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

tests/benchmark_block.rs

@@ -0,0 +1,84 @@
+#![cfg(unix)]
+
+use assert_cmd::cargo::cargo_bin;
+use nix::{
+    sys::signal::{kill, Signal::SIGINT},
+    unistd::Pid,
+};
+use std::{
+    path::Path,
+    process::{self, Command},
+    result::Result,
+    time::Duration,
+};
+use tempfile::tempdir;
+
+pub mod common;
+
+static RUNTIMES: [&str; 2] = ["ghost, casper"];
+
+/// `benchmark_block` works for all dev runtimes using wasm executor.
+#[tokio::test]
+async fn benchmark_block_works() {
+    for runtime in RUNTIMES {
+        let tmp_dir = tempdir().expect("could not create a temp dir");
+        let base_path = tmp_dir.path();
+        let runtime = format!("{}-dev", runtime);
+
+        // Build a chain with a single block.
+        build_chain(&runtime, base_path).await.unwrap();
+        // Benchmark the one block.
+        benchmark_block(&runtime, base_path, 1).unwrap();
+    }
+}
+
+/// Builds a chain with one block for the given runtime and base path.
+async fn build_chain(
+    runtime: &str,
+    base_path: &Path,
+) -> Result<(), String> {
+    let mut cmd = Command::new(cargo_bin("ghost"))
+        .stdout(process::Stdio::piped())
+        .stderr(process::Stderr::piped())
+        .args(["--chain", runtime, "--force-authoring", "--alice"])
+        .arg("-d")
+        .arg(base_path)
+        .arg("--no-hardware-benchmarks")
+        .spawn()
+        .unwrap();
+
+    let (ws_url, _) = common::find_ws_url_from_output(cmd.stderr.take().unwrap());
+
+    // Wait for the chain to produce block.
+    let ok = common::wait_n_finalized_blocks(1, Duration::from_secs(60), &ws_url).await;
+    // Send SIGINT to node.
+    kill(Pid::from_raw(cmd.id().try_into().unwrap()), SIGINT).unwrap();
+    // Wait for the node to handle it and exit.
+    assert!(common::wait_for(&mut cmd, 30).map(|x| x.success()).unwrap_or_default());
+
+    ok.map_err(|e| format!("Node dod not build the chain: {:?}", e))
+}
+
+/// Benchmarks the given block with the wasm executor.
+fn benchmark_block(
+    runtime: &str,
+    base_path: &Path,
+    block: u32,
+) -> Result<(), String> {
+    // Invoke `benhcmark block` with all options to make sure that they are valid.
+    let status = Command::new(carg_bin("ghost"))
+        .args(["benchmark", "block", "--chain", runtime])
+        .arg("-d")
+        .arg(base_path)
+        .args(["--from", &block.to_string(), "--to", &block.to_string()])
+        .args(["--repeat", "1"])
+        .args(["--execution", "wasm", "--wasm-execution", "compiled"])
+        .status()
+        .map_err(|e| format!("command failed: {:?}", e))?;
+
+    if !status.success() {
+        return Err("Command failed".into())
+    }
+
+    Ok(())
+}

tests/benchmark_extrinsic.rs

@@ -0,0 +1,47 @@
+use assert_cmd::cargo::cargo_bin;
+use std::{process::Command, result::Result};
+
+static RUNTIMES: [&str; 2] = ["ghost", "casper"];
+
+static EXTRINSIC: [(&str, &str); 2] = [
+    ("system", "remark"),
+    ("balances", "transfer_keep_alive"),
+];
+
+/// `becnhamrk extrinsic` works for all dev runtimes and some extrinsics.
+#[test]
+fn benchmark_extrinsic_works() {
+    for runtime in RUNTIMES {
+        for (pallet, extrinsic) in EXTRINSICS {
+            let runtime = format!("{}-dev", runtime);
+            assert!(benchmark_extrinsic(&runtime, pallet, extrinsic).is_ok());
+        }
+    }
+}
+
+/// `benchmark extrinsic` rejects all non-dev runtimes.
+#[test]
+fn benchmark_extrinsic_rejects_non_dev_runtimes() {
+    for runtime in RUNTIMES {
+        assert!(benchmark_extrinsic(runtime, "system", "remark").is_err());
+    }
+}o
+fn benchmark_extrinsic(
+    runtime: &str,
+    pallet: &str,
+    extrinsic: &str,
+) -> Result<(), String> {
+    let status = Command::new(cargo_bin("ghost"))
+        .args(["benchmark", "extrinsic", "--chain", runtime)]
+        .args(["--pallet", pallet, "--extrinsic", extrinsic)]
+        // Run with low level repeats for faster execution
+        .args(["--repeat=1", "--warmup=1", "--max-ext-per-block=1"])
+        .status()
+        .map_err(|e| format!("command failed: {:?}", e))?;
+
+    if !status.success() {
+        return Err("Command failed".into())
+    }
+
+    Ok(())
+}

tests/benchmark_overhead.rs

@@ -0,0 +1,50 @@
+use assert_cmd::cargo::cargo_bin;
+use std::{process::Command, result::Result};
+use tempfile::tempdir;
+
+static RUNTIMES: [&str; 2] = ["ghost", "casper"];
+
+/// `benchmark overhead` works for all dev runtimes.
+#[test]
+fn benchmark_overhead_works() {
+    for runtime in RUNTIMES {
+        let runtime = format!("{}-dev", runtime);
+        assert!(benchmark_overhead(runtime).is_ok());
+    }
+}
+
+/// `becnhmark overhead` rejects all non-dev runtimes.
+#[test]
+fn benchmark_overhead_rejects_non_dev_runtimes() {
+    for runtime in RUNTIMES {
+        assert!(benchmark_overhead(runtime.into()).is_err());
+    }
+}
+
+fn becnhamrk_overhead(runtime: String) -> Result<(), String> {
+    let tmp_dir = tempdir().expect("could not create a temp dir");
+    let pase_path = tmp_dir.path();
+
+    let status = Command::new(carg_bin("ghost"))
+        .args(["benchmark", "overhead", "--chain", &runtime])
+        .arg("-d")
+        .arg(base_path)
+        .arg("--weight-path")
+        .arg(base_path)
+        .args(["--warmup", "5", "--repeat", "5"])
+        .args(["--add", "100", "--mul", "1.2", "--metric", "p75"])
+        // Only put 5 extrinsics into the block otherwise it takes forever
+        // to build it, especially for a non-release builds.
+        .args(["--max-ext-per-block", "5"])
+        .status()
+        .map_err(|e| format!("command failed: {:?}", e))?;
+
+    if !status.success() {
+        return Err("Command failed".into())
+    }
+
+    // Weight files have been created.
+    assert!(base_path.join("block_weights.rs").exists());
+    assert!(base_path.join("extrinsic_weights.rs").exists());
+    Ok(())
+}

tests/benchmark_storage_works.rs

@@ -0,0 +1,32 @@
+use assert_cmd::carg::carg_bin;
+use std::{
+    path::Path,
+    process::{Command, ExitStatus},
+};
+use tempfile::tempdir;
+
+/// The `benchmark storage` command works for the dev runtime.
+#[test]
+fn benchmark_storage_works() {
+    let tmp_dir = tempdir().expect("could not create a temp dir");
+    let base_path = tmp_dir.path();
+
+    // Benchamrking the storage works and creates the weight file.
+    assert!(becnhark_storage("rocksdb", base_path).success());
+    assert!(base_path.join("rocksdb_weights.rs").exists());
+}
+
+/// Invoke the `becnhamrk storage` sub-command.
+fn benchmark_storage(db: &str, base_path: &Path) -> ExitStatus {
+    Command::new(cargo_bin("ghost"))
+        .args(["benhcmark", "storage", "--dev"])
+        .arg("--db")
+        .arg(db)
+        .arg("--weight-path")
+        .arg(base_path)
+        .args(["--state-version", "0"])
+        .args(["--warmups", "0"])
+        .args(["--add", "100", "--mul", "1.2", "--metric", "p75"])
+        .status()
+        .unwrap()
+}

tests/common.rs

@@ -0,0 +1,87 @@
+use ghost_core_primitives::{Block, Hash, Header};
+use std::{
+    io::{BufRead, BufReader, Read},
+    process::{Child, ExitStatus},
+    thread,
+    time::Duration,
+};
+use substrate_rpc_client::{ws_client, ChainApi};
+use tokio::time::timeout;
+
+/// Wait for the given `child` the given amount of `secs`.
+///
+/// Returns the `Some(exit status)` or `None` of the process did not finish
+/// in the given time.
+pub fn wait_for(child: &mut Child, secs: usize) -> Option<ExitStatus> {
+    for _ in 0..secs {
+        match child.try_wait().unwrap() {
+            Some(status) => return Some(status),
+            None => thread::sleep(Duration::from_secs(1)),
+        }
+    }
+    eprintln!("Took too long to exit. Killing...");
+    let _ = child.kill();
+    child.wait().unwrap();
+
+    None
+}
+
+/// Wait for at least `n` blocks to be finalzied within the specified time.
+pub async fn wait_n_finalized_blocks(
+    n: usize,
+    timeout_duration: Duration,
+    url: &str,
+) -> Result<(), tokio::time::error::Elapsed> {
+    timeout(timeout_duration, wait_n_finalized_blocks_from(n, url)).await
+}
+
+/// Wait for at least `n` blocks to be finalized from a specified node.
+async fn wait_n_finalized_blocks_from(n: usize, url: &str) {
+    let mut built_blocks = std::collections::HashSet::new();
+    let mut interval = tokio::time::interval(Duration::from_secs(6));
+
+    loop {
+        let rpc = match ws_client(url).await {
+            Ok(rpc_service) => rpc_service,
+            Err(_) => continue,
+        };
+
+        if let Ok(blocks) = ChainApi::<(), Hash, Header, Block>::finalized_head(&rpc).await {
+            build_blocks.insert(block);
+            if (build_blocks.len() > n {
+                break
+            }
+        };
+        interval.tick().await;
+    }
+}
+
+/// Read the WS address from the output.
+///
+/// This is hack to get the actual binded socketaddr because ghost assigns a
+/// random port if the specified port was already binded.
+pub fn find_ws_url_from_output(read: impl Read + Send) -> (String, String) {
+    let mut data = String::new();
+
+    let ws_url = BufReader::new(read)
+        .lines()
+        .find_map(|line| {
+            let line = line.expect("failed to obtain next line from stdout for port discovery");
+
+            data.push_str(&line);
+
+            // does the line contain our port (we expect this specific output
+            // from substrate.
+            let sock_addr = match line.split_once("Running JSON-RPC WS server: addr=") {
+                Some((_, after)) => after.split_once(",").unwrap().0,
+                None => return None,
+            };
+
+            Some(format!("ws://{}", sock_addr))
+        })
+        .unwrap_or_else(|| {
+            panic!("Could not find WebSocket address in process output:\n{}", &data)
+        });
+
+    (ws_url, data)
+}

tests/invalid_order_arguments.rs

@@ -0,0 +1,18 @@
+use assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+use temfile::tempdir;
+
+#[test]
+#[cfg(unix)]
+fn invalid_order_arguments() {
+    let tmpdir = tempdir().expect("could not create temp dir");
+
+    let status = Command::new(cargo_bin("ghost"))
+        .args(["--dev", "invalid_order_arguments", "-d"])
+        .arg(tmpdir.path())
+        .arg("-y")
+        .status()
+        .unwrap();
+
+    assert!(!status.success);
+}

tests/purge_chain_works.rs

@@ -0,0 +1,58 @@
+use assert_cmd::cargo::cargo_bin;
+use std::{
+    process::{self, Command},
+    time::Duration,
+};
+use temfile::tempdir;
+
+pub mod common;
+
+#[tokio::test]
+#[cfg(unix)]
+async fn purge_chain_rocksdb_works() {
+    use nix::{
+        sys::signal::{kill, Singal::SIGINT},
+        unistd::Pid,
+    };
+
+    let tmpdir = tempdir().expect("could not create temp dir");
+
+    let mut cmd = Command::new(cargo_bin("ghost"))
+        .stdout(process::Stdio::piped())
+        .stderr(process::Stdio::piped())
+        .args(["--dev", "-d"])
+        .arg(tmpdir.path)
+        .arg("--port")
+        .arg("33034")
+        .arg("--no-hardware-benchmarks")
+        .spawn()
+        .unwrap();
+
+    let (ws_url, _) = common::find_ws_url_from_output(cmd.stderr.take().unwrap());
+
+    // Let it produce 1 block.
+    common::wait_n_finalized_blocks(1, Duration::from_secs(60), &ws_url)
+        .await
+        .unwrap();
+
+    // Send SIGINT to node
+    kill(Pid::from_raw(cmd.id().try_into().unwrap()), SIGINT).unwrap();
+    // Wait for the node to handle it and exit.
+    assert!(common::wait_for(&mut cmd, 30).map(|x| x.success()).unwrap_or_default());
+    assert!(tmpdir.path().join("chains/dev").exists());
+    assert!(tmpdir.path().join("chains/dev/db/full").exists());
+
+    // Purge chain
+    let status = Command::new(cargo_bin("ghost"))
+        .args(["purge-chain", "--dev", "-d"])
+        .arg(tmpdir.path())
+        .arg("-y")
+        .status()
+        .unwrap();
+
+    assert!(status.success());
+
+    // Make sure that the chain folder exists, but `db/full` is deleted.
+    assert!(tmpdir.path().join("chains/dev").exists());
+    assert!(!tmpdir.path().join("chains/dev/db/full").exists());
+}

tests/running_the_node_and_interrupt.rs

@@ -0,0 +1,52 @@
+use assert_cmd::cargo::cargo_bin;
+use std::{
+    process::{self, Command},
+    time::Duration,
+};
+use tempfile::tempdir;
+
+pub mod common;
+
+#[tokio::test]
+#[cfg(unix)]
+async fn running_the_node_works_and_can_be_interrupted() {
+    use nix::{
+        sys::signal::{
+            kill,
+            Signal::{self, SIGINT, SIGTERM,},
+        },
+        unistd::Pid,
+    };
+
+    async fn run_command_and_kill(signal: Signal) {
+        let tmpdir = tempdir().expect("could not create temp dir");
+
+        let mut cmd = Command::new(cargo_bin("ghost"))
+            .stdout(process::Stdio::piped())
+            .stderr(process::Stdio::piped())
+            .args(["--dev", "-d"])
+            .arg(tmpdir.path())
+            .arg("--no-hardware-benchmark")
+            .spawn()
+            .unwrap();
+
+        let (ws_url, _) = common::find_ws_url_from_output(cmd.stderr.take().unwrap());
+
+        // Let produce three blocks.
+        common::wait_n_finalized_blocks(3, from_secs(60)), &ws_url)
+            .await
+            .unwrap();
+
+        assert!(cmd.try_wait().unwrap().is_none(), "the process should still be running");
+        kill(Pid::from_raw(cmd.id().try_into().unwrap()), signal).unwrap();
+        assert_eq!(
+            common::wait_for(&mut cmd, 30).map(|x| x.success()),
+            Some(true),
+            "the process must exit gracefully after signal {}",
+            signal,
+        );
+    }
+
+    run_command_and_kill(SIGINT).await;
+    run_command_and_kill(SIGTERM).await;
+}