Add contract-with-tests template

Author: xxuejie

cargo-generate.toml

@@ -1,5 +1,6 @@
 [template]
 sub_templates = [
   "contract",
+  "contract-with-tests",
   "workspace",
 ]

contract-with-tests/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "{{project-name}}"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ckb-std = "0.15.0"
+
+[dev-dependencies]
+ckb-testtool = "0.10.1"
+serde_json = "1.0"

contract-with-tests/Makefile

@@ -0,0 +1,78 @@
+# We cannot use $(shell pwd), which will return unix path format on Windows,
+# making it hard to use.
+cur_dir = $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
+
+TOP := $(cur_dir)
+# RUSTFLAGS that are likely to be tweaked by developers. For example,
+# while we enable debug logs by default here, some might want to strip them
+# for minimal code size / consumed cycles.
+CUSTOM_RUSTFLAGS := --cfg debug_assertions
+# RUSTFLAGS that are less likely to be tweaked by developers. Most likely
+# one would want to keep the default values here.
+FULL_RUSTFLAGS := -C target-feature=+zba,+zbb,+zbc,+zbs $(CUSTOM_RUSTFLAGS)
+# Additional cargo args to append here. For example, one can use
+# make test CARGO_ARGS="-- --nocapture" so as to inspect data emitted to
+# stdout in unit tests
+CARGO_ARGS :=
+MODE := release
+# Tweak this to change the clang version to use for building C code. By default
+# we use a bash script with somes heuristics to find clang in current system.
+CLANG := $(shell $(TOP)/scripts/find_clang)
+# When this is set to some value, the generated binaries will be copied over
+BUILD_DIR := build/$(MODE)
+# Generated binaries to copy. By convention, a Rust crate's directory name will
+# likely match the crate name, which is also the name of the final binary.
+# However if this is not the case, you can tweak this variable. As the name hints,
+# more than one binary is supported here.
+BINARIES := $(notdir $(shell pwd))
+
+ifeq (release,$(MODE))
+	MODE_ARGS := --release
+endif
+
+default: build test
+
+build:
+	RUSTFLAGS="$(FULL_RUSTFLAGS)" TARGET_CC="$(CLANG)" \
+		cargo build --target=riscv64imac-unknown-none-elf $(MODE_ARGS) $(CARGO_ARGS)
+	mkdir -p $(BUILD_DIR)
+	@set -eu; \
+	if [ "x$(BUILD_DIR)" != "x" ]; then \
+		for binary in $(BINARIES); do \
+			echo "Copying binary $$binary to build directory"; \
+			cp $(TOP)/target/riscv64imac-unknown-none-elf/$(MODE)/$$binary $(TOP)/$(BUILD_DIR); \
+		done \
+	fi
+
+# test, check, clippy and fmt here are provided for completeness,
+# there is nothing wrong invoking cargo directly instead of make.
+test:
+	cargo test $(CARGO_ARGS)
+
+check:
+	cargo check $(CARGO_ARGS)
+
+clippy:
+	cargo clippy $(CARGO_ARGS)
+
+fmt:
+	cargo fmt $(CARGO_ARGS)
+
+# Arbitrary cargo command is supported here. For example:
+#
+# make cargo CARGO_CMD=expand CARGO_ARGS="--ugly"
+# 
+# Invokes:
+# cargo expand --ugly
+CARGO_CMD :=
+cargo:
+	cargo $(CARGO_CMD) $(CARGO_ARGS)
+
+clean:
+	rm -rf build
+	cargo clean
+
+prepare:
+	rustup target add riscv64imac-unknown-none-elf
+
+.PHONY: build test check clippy fmt cargo clean prepare

contract-with-tests/scripts/find_clang

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+#
+# An utility script used to find a binary of clang 16+
+
+if [[ -n "${CLANG}" ]]; then
+  echo "${CLANG}"
+  exit 0
+fi
+
+CANDIDATES=("clang" "clang-16" "clang-17")
+
+BREW_PREFIX=$(brew --prefix 2> /dev/null)
+if [[ -n "${BREW_PREFIX}" ]]; then
+  CANDIDATES+=(
+    "${BREW_PREFIX}/opt/llvm/bin/clang"
+    "${BREW_PREFIX}/opt/llvm@16/bin/clang"
+    "${BREW_PREFIX}/opt/llvm@17/bin/clang"
+  )
+fi
+
+for candidate in ${CANDIDATES[@]}; do
+  OUTPUT=$($candidate -dumpversion 2> /dev/null | cut -d'.' -f 1)
+
+  if [[ $((OUTPUT)) -ge 16 ]]; then
+    echo "$candidate"
+    exit 0
+  fi
+done
+
+>&2 echo "Cannot find clang of version 16+!"
+exit 1

contract-with-tests/src/main.rs

@@ -0,0 +1,21 @@
+#![cfg_attr(target_arch = "riscv64", no_std)]
+#![cfg_attr(not(test), no_main)]
+
+#[cfg(test)]
+extern crate alloc;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(not(test))]
+use ckb_std::default_alloc;
+#[cfg(not(test))]
+ckb_std::entry!(program_entry);
+#[cfg(not(test))]
+default_alloc!();
+
+pub fn program_entry() -> i8 {
+    ckb_std::debug!("This is a sample contract!");
+
+    0
+}

contract-with-tests/src/tests/mod.rs

@@ -0,0 +1,114 @@
+#![allow(dead_code)]
+
+use ckb_testtool::{
+    ckb_error::Error,
+    ckb_types::{
+        bytes::Bytes,
+        core::{Cycle, TransactionView},
+    },
+    context::Context,
+};
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+use std::str::FromStr;
+
+#[cfg(test)]
+mod tests;
+
+// The exact same Loader code from capsule's template, except that
+// now we use MODE as the environment variable
+const TEST_ENV_VAR: &str = "MODE";
+
+pub enum TestEnv {
+    Debug,
+    Release,
+}
+
+impl FromStr for TestEnv {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "debug" => Ok(TestEnv::Debug),
+            "release" => Ok(TestEnv::Release),
+            _ => Err("no match"),
+        }
+    }
+}
+
+pub struct Loader(PathBuf);
+
+impl Default for Loader {
+    fn default() -> Self {
+        let test_env = match env::var(TEST_ENV_VAR) {
+            Ok(val) => val.parse().expect("test env"),
+            Err(_) => TestEnv::Release,
+        };
+        Self::with_test_env(test_env)
+    }
+}
+
+impl Loader {
+    fn with_test_env(env: TestEnv) -> Self {
+        let load_prefix = match env {
+            TestEnv::Debug => "debug",
+            TestEnv::Release => "release",
+        };
+        let mut base_path = match env::var("TOP") {
+            Ok(val) => {
+                let mut base_path: PathBuf = val.into();
+                base_path.push("build");
+                base_path
+            }
+            Err(_) => {
+                let mut base_path = PathBuf::new();
+                // cargo may use a different cwd when running tests, for example:
+                // when running debug in vscode, it will use workspace root as cwd by default,
+                // when running test by `cargo test`, it will use tests directory as cwd,
+                // so we need a fallback path
+                base_path.push("build");
+                if !base_path.exists() {
+                    base_path.pop();
+                    base_path.push("..");
+                    base_path.push("build");
+                }
+                base_path
+            }
+        };
+
+        base_path.push(load_prefix);
+        Loader(base_path)
+    }
+
+    pub fn load_binary(&self, name: &str) -> Bytes {
+        let mut path = self.0.clone();
+        path.push(name);
+        let result = fs::read(&path);
+        if result.is_err() {
+            panic!("Binary {:?} is missing!", path);
+        }
+        result.unwrap().into()
+    }
+}
+
+// This helper method runs Context::verify_tx, but in case error happens,
+// it also dumps current transaction to failed_txs folder.
+pub fn verify_and_dump_failed_tx(
+    context: &Context,
+    tx: &TransactionView,
+    max_cycles: u64,
+) -> Result<Cycle, Error> {
+    let result = context.verify_tx(tx, max_cycles);
+    if result.is_err() {
+        let mut path = env::current_dir().expect("current dir");
+        path.push("failed_txs");
+        std::fs::create_dir_all(&path).expect("create failed_txs dir");
+        let mock_tx = context.dump_tx(tx).expect("dump failed tx");
+        let json = serde_json::to_string_pretty(&mock_tx).expect("json");
+        path.push(format!("0x{:x}.json", tx.hash()));
+        println!("Failed tx written to {:?}", path);
+        std::fs::write(path, json).expect("write");
+    }
+    result
+}

contract-with-tests/src/tests/tests.rs

@@ -0,0 +1,9 @@
+// Include your tests here
+// See https://github.com/xxuejie/ckb-native-build-sample/blob/main/tests/src/tests.rs for examples
+
+use super::Loader;
+
+#[test]
+fn test_binary_exists() {
+    Loader::default().load_binary("{{project-name}}");
+}