more test changes

src/new/templates/test/chat/tests.toml

@@ -6,7 +6,7 @@ runtime_build_release = false
 [[tests]]
 setup_package_paths = [".."]
 test_packages = [
-    { path = "{package_name}_test", grant_capabilities = ["{package_name}:{package_name}:template.os"] },
+    { path = "{package_name}_test", grant_capabilities = ["{package_name}:{package_name}:{publisher}"] },
 ]
 timeout_secs = 5
 fakechain_router = 8545

src/new/templates/test/chat/{package_name}_test/{package_name}_test/src/lib.rs

@@ -1,7 +1,7 @@
 use crate::kinode::process::{package_name}::{ChatMessage, Request as ChatRequest, Response as ChatResponse, SendRequest};
 use crate::kinode::process::tester::{Request as TesterRequest, Response as TesterResponse, RunRequest, FailResponse};
 
-use kinode_process_lib::{await_message, call_init, print_to_terminal, println, Address, Message, ProcessId, Request, Response};
+use kinode_process_lib::{await_message, call_init, print_to_terminal, println, Address, ProcessId, Request, Response};
 
 mod tester_lib;
 
@@ -15,80 +15,79 @@ wit_bindgen::generate!({
 fn handle_message (our: &Address) -> anyhow::Result<()> {
     let message = await_message().unwrap();
 
-    match message {
-        Message::Response { .. } => { unimplemented!() },
-        Message::Request { ref source, ref body, .. } => {
-            if our.node != source.node {
-                return Err(anyhow::anyhow!(
-                    "rejecting foreign Message from {:?}",
-                    source,
-                ));
-            }
-            match serde_json::from_slice(body)? {
-                TesterRequest::Run(RunRequest { input_node_names: node_names, .. }) => {
-                    print_to_terminal(0, "{package_name}_test: a");
-                    assert!(node_names.len() >= 2);
-                    if our.node != node_names[0] {
-                        // we are not master node: return
-                        Response::new()
-                            .body(TesterResponse::Run(Ok(())))
-                            .send()
-                            .unwrap();
-                        return Ok(());
-                    }
+    if !message.is_request() {
+        unimplemented!();
+    }
+    let source = message.source();
+    if our.node != source.node {
+        return Err(anyhow::anyhow!(
+            "rejecting foreign Message from {:?}",
+            source,
+        ));
+    }
+    let TesterRequest::Run(RunRequest {
+        input_node_names: node_names,
+        ..
+    }) = message.body().try_into()?;
+    print_to_terminal(0, "{package_name}_test: a");
+    assert!(node_names.len() >= 2);
+    if our.node != node_names[0] {
+        // we are not master node: return
+        Response::new()
+            .body(TesterResponse::Run(Ok(())))
+            .send()
+            .unwrap();
+        return Ok(());
+    }
 
-                    // we are master node
+    // we are master node
 
-                    let our_chat_address = Address {
-                        node: our.node.clone(),
-                        process: ProcessId::new(Some("{package_name}"), "{package_name}", "{publisher}"),
-                    };
-                    let their_chat_address = Address {
-                        node: node_names[1].clone(),
-                        process: ProcessId::new(Some("{package_name}"), "{package_name}", "{publisher}"),
-                    };
+    let our_chat_address = Address {
+        node: our.node.clone(),
+        process: ProcessId::new(Some("{package_name}"), "{package_name}", "{publisher}"),
+    };
+    let their_chat_address = Address {
+        node: node_names[1].clone(),
+        process: ProcessId::new(Some("{package_name}"), "{package_name}", "{publisher}"),
+    };
 
-                    // Send
-                    print_to_terminal(0, "{package_name}_test: b");
-                    let message: String = "hello".into();
-                    let _ = Request::new()
-                        .target(our_chat_address.clone())
-                        .body(ChatRequest::Send(SendRequest {
-                            target: node_names[1].clone(),
-                            message: message.clone(),
-                        }))
-                        .send_and_await_response(15)?.unwrap();
+    // Send
+    print_to_terminal(0, "{package_name}_test: b");
+    let message: String = "hello".into();
+    let _ = Request::new()
+        .target(our_chat_address.clone())
+        .body(ChatRequest::Send(SendRequest {
+            target: node_names[1].clone(),
+            message: message.clone(),
+        }))
+        .send_and_await_response(15)?.unwrap();
 
-                    // Get history from receiver & test
-                    print_to_terminal(0, "{package_name}_test: c");
-                    let response = Request::new()
-                        .target(their_chat_address.clone())
-                        .body(ChatRequest::History(our.node.clone()))
-                        .send_and_await_response(15)?.unwrap();
-                    if response.is_request() { panic!("") };
-                    let ChatResponse::History(messages) = response.body().try_into()? else {
-                        fail!("{package_name}_test");
-                    };
-                    let expected_messages = vec![ChatMessage {
-                        author: our.node.clone(),
-                        content: message,
-                    }];
+    // Get history from receiver & test
+    print_to_terminal(0, "{package_name}_test: c");
+    let response = Request::new()
+        .target(their_chat_address.clone())
+        .body(ChatRequest::History(our.node.clone()))
+        .send_and_await_response(15)?.unwrap();
+    if response.is_request() { fail!("{package_name}_test"); };
+    let ChatResponse::History(messages) = response.body().try_into()? else {
+        fail!("{package_name}_test");
+    };
+    let expected_messages = vec![ChatMessage {
+        author: our.node.clone(),
+        content: message,
+    }];
 
-                    if messages != expected_messages {
-                        println!("{messages:?} != {expected_messages:?}");
-                        fail!("{package_name}_test");
-                    }
+    if messages != expected_messages {
+        println!("{messages:?} != {expected_messages:?}");
+        fail!("{package_name}_test");
+    }
 
-                    Response::new()
-                        .body(TesterResponse::Run(Ok(())))
-                        .send()
-                        .unwrap();
-                },
-            }
+    Response::new()
+        .body(TesterResponse::Run(Ok(())))
+        .send()
+        .unwrap();
 
-            Ok(())
-        },
-    }
+    Ok(())
 }
 
 call_init!(init);

src/new/templates/test/echo/tests.toml

@@ -0,0 +1,18 @@
+runtime = { FetchVersion = "latest" }
+# runtime = { RepoPath = "~/git/kinode" }
+runtime_build_release = false
+
+
+[[tests]]
+setup_package_paths = [".."]
+test_packages = [
+    { path = "{package_name}_test", grant_capabilities = ["{package_name}:{package_name}:{publisher}"] },
+]
+timeout_secs = 5
+fakechain_router = 8545
+
+[[tests.nodes]]
+port = 8080
+home = "home/first"
+fake_node_name = "first.dev"
+runtime_verbosity = 0

src/new/templates/test/echo/{package_name}_test/Cargo.toml_

@@ -0,0 +1,10 @@
+[workspace]
+resolver = "2"
+members = [
+    "{package_name}_test",
+]
+
+[profile.release]
+panic = "abort"
+opt-level = "s"
+lto = true

src/new/templates/test/echo/{package_name}_test/api/tester:sys-v0.wit

@@ -0,0 +1,27 @@
+interface tester {
+    variant request {
+        run(run-request),
+    }
+
+    variant response {
+        run(result<_, fail-response>)
+    }
+
+    record run-request {
+        input-node-names: list<string>,
+        test-names: list<string>,
+        test-timeout: u64,
+    }
+
+    record fail-response {
+        test: string,
+        file: string,
+        line: u32,
+        column: u32,
+    }
+}
+
+world tester-sys-v0 {
+    import tester;
+    include process-v0;
+}

src/new/templates/test/echo/{package_name}_test/metadata.json

@@ -0,0 +1,17 @@
+{
+    "name": "{package_name} Test",
+    "description": "A test for {package_name}.",
+    "image": "",
+    "properties": {
+        "package_name": "{package_name}_test",
+        "current_version": "0.1.0",
+        "publisher": "{publisher}",
+        "mirrors": [],
+        "code_hashes": {
+            "0.1.0": ""
+        },
+        "wit_version": 0
+    },
+    "external_url": "",
+    "animation_url": ""
+}

src/new/templates/test/echo/{package_name}_test/pkg/manifest.json

@@ -0,0 +1,13 @@
+[
+    {
+        "process_name": "{package_name}_test",
+        "process_wasm_path": "/{package_name}_test.wasm",
+        "on_exit": "Restart",
+        "request_networking": false,
+        "request_capabilities": [],
+        "grant_capabilities": [
+            "{package_name}:{package_name}:{publisher}"
+        ],
+        "public": true
+    }
+]

src/new/templates/test/echo/{package_name}_test/{package_name}_test/Cargo.toml_

@@ -0,0 +1,21 @@
+[package]
+name = "{package_name}_test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0"
+bincode = "1.3"
+kinode_process_lib = { git = "https://github.com/kinode-dao/process_lib", rev = "b492f3b" }
+process_macros = { git = "https://github.com/kinode-dao/process_macros", rev = "626e501" }
+rmp-serde = "1.1"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+thiserror = "1.0"
+wit-bindgen = "0.24.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[package.metadata.component]
+package = "kinode:process"

src/new/templates/test/echo/{package_name}_test/{package_name}_test/src/lib.rs

@@ -0,0 +1,75 @@
+use crate::kinode::process::tester::{Request as TesterRequest, Response as TesterResponse, RunRequest, FailResponse};
+
+use kinode_process_lib::{await_message, call_init, print_to_terminal, println, Address, ProcessId, Request, Response};
+
+mod tester_lib;
+
+wit_bindgen::generate!({
+    path: "target/wit",
+    world: "tester-sys-v0",
+    generate_unused_types: true,
+    additional_derives: [PartialEq, serde::Deserialize, serde::Serialize, process_macros::SerdeJsonInto],
+});
+
+fn handle_message (our: &Address) -> anyhow::Result<()> {
+    let message = await_message().unwrap();
+
+    if !message.is_request() {
+        unimplemented!();
+    }
+    let source = message.source();
+    if our.node != source.node {
+        return Err(anyhow::anyhow!(
+            "rejecting foreign Message from {:?}",
+            source,
+        ));
+    }
+    let TesterRequest::Run(RunRequest {
+        input_node_names: node_names,
+        ..
+    }) = message.body().try_into()?;
+    print_to_terminal(0, "{package_name}_test: a");
+    assert!(node_names.len() == 1);
+
+    let our_echo_address = Address {
+        node: our.node.clone(),
+        process: ProcessId::new(Some("{package_name}"), "{package_name}", "{publisher}"),
+    };
+
+    // Send
+    print_to_terminal(0, "{package_name}_test: b");
+    let message: String = "hello".into();
+    let response = Request::new()
+        .target(our_echo_address)
+        .body(serde_json::to_vec("test")?)
+        .send_and_await_response(15)?.unwrap();
+    if response.is_request() { fail!("{package_name}_test"); };
+    if serde_json::json!("Ack") != serde_json::from_slice::<serde_json::Value>(
+        response.body()
+    ) {
+        fail!("{package_name}_test");
+    };
+
+    Response::new()
+        .body(TesterResponse::Run(Ok(())))
+        .send()
+        .unwrap();
+
+    Ok(())
+}
+
+call_init!(init);
+fn init(our: Address) {
+    print_to_terminal(0, "begin");
+
+    loop {
+        match handle_message(&our) {
+            Ok(()) => {},
+            Err(e) => {
+                print_to_terminal(0, format!("{package_name}_test: error: {e:?}").as_str());
+
+                fail!("{package_name}_test");
+            },
+        };
+    }
+}

src/new/templates/test/echo/{package_name}_test/{package_name}_test/src/tester_lib.rs

@@ -0,0 +1,31 @@
+use crate::kinode::process::tester::{
+    Response as TesterResponse, FailResponse,
+};
+
+#[macro_export]
+macro_rules! fail {
+    ($test:expr) => {
+        Response::new()
+            .body(TesterResponse::Run(Err(FailResponse {
+                test: $test.into(),
+                file: file!().into(),
+                line: line!(),
+                column: column!(),
+            })))
+            .send()
+            .unwrap();
+        panic!("")
+    };
+    ($test:expr, $file:expr, $line:expr, $column:expr) => {
+        Response::new()
+            .body(TesterResponse::Run(Err(FailResponse {
+                test: $test.into(),
+                file: $file.into(),
+                line: $line,
+                column: $column,
+            })))
+            .send()
+            .unwrap();
+        panic!("")
+    };
+}