fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-07-31 20:11:55 +00:00
Code Issues Projects Releases Wiki Activity

Add a test harness to directly execute wasm tests (#524)

Browse Source 
* Add a test harness to directly execute wasm tests

This commits adds a few new crates and infrastructure to enable comands like:

    cargo test --target wasm32-unknown-unknown

The intention here is to make it as low-friction as possible to write wasm tests
and also have them execute in a reasonable amount of time. Eventually this is
also hopefully enough support to do things like headless testing!

For now though this is defintely MVP status rather than fully fleshed out.
There's some more information at `crates/test/README.md` about how it works and
how to use it, but for now this is mainly intended to play around with locally
in this repository for our own tests.

* Port a numbe of `js-sys` tests to the new test framework

This commit ports a number of existing tests for the `js-sys` crate over to the
new test framework created in the previous commit, showing off how they can be
executed as well as drastictlly simplifying the tests themselves! This is
intended to be a proof of concept for now which we can refine over time. This
should also show off that it's possible to incrementally move over to the new
test framework.
This commit is contained in:
Alex Crichton
2018-07-20 13:47:49 -05:00
committed by GitHub
parent 722a87f324
commit f8d336d711
27 changed files with 946 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
crates/test/Cargo.toml Normal file
View File

@@ -0,0 +1,13 @@
[package]
name = "wasm-bindgen-test"
version = "0.2.12"
authors = ["The wasm-bindgen Developers"]
[dependencies]
wasm-bindgen-test-macro = { path = '../test-macro', version = '=0.2.12' }
wasm-bindgen = { path = '../..', version = '0.2.12' }
js-sys = { path = '../js-sys', version = '0.2.12' }
console_error_panic_hook = '0.1'
[lib]
test = false

170
crates/test/README.md Normal file
View File

@@ -0,0 +1,170 @@
# wasm-bindgen-test
This crate is an experimental test harness for `wasm32-unknown-unknown`, with
the goal of allowing you to write tests as you normally do in Rust and then
simply:
```
cargo test --target wasm32-unknown-unknown
```
This project is still in the early stages of its development so there's not a
ton of documentation just yet, but a taste of how it works is:
* First, install the test runner.
```
cargo install --path crates/test-runner
```
* Next, add this to your `.cargo/config`:
```toml
[target.wasm32-unknown-unknown]
runner = 'wasm-bindgen-test-runner'
```
* Next, configure your project's dev-dependencies:
```toml
[dev-dependencies]
# or [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
wasm-bindgen-test = { git = 'https://github.com/rustwasm/wasm-bindgen' }
```
* Next, write some tests!
```rust
// in tests/wasm.rs
#![feature(use_extern_macros)]
extern crate wasm_bindgen_test;
use wasm_bindgen_test::*;
#[wasm_bindgen_test]
fn pass() {
assert_eq!(1, 1);
}
#[wasm_bindgen_test]
fn fail() {
assert_eq!(1, 2);
}
```
* And finally, execute your tests:
```
$ cargo test --target wasm32-unknown-unknown
Finished dev [unoptimized + debuginfo] target(s) in 0.11s
Running /home/.../target/wasm32-unknown-unknown/debug/deps/wasm-4a309ffe6ad80503.wasm
running 2 tests
test wasm::pass ... ok
test wasm::fail ... FAILED
failures:
---- wasm::fail output ----
error output:
panicked at 'assertion failed: `(left == right)`
left: `1`,
right: `2`', crates/test/tests/wasm.rs:14:5
JS exception that was thrown:
RuntimeError: unreachable
at __rust_start_panic (wasm-function[1362]:33)
at rust_panic (wasm-function[1357]:30)
at std::panicking::rust_panic_with_hook::h56e5e464b0e7fc22 (wasm-function[1352]:444)
at std::panicking::continue_panic_fmt::had70ba48785b9a8f (wasm-function[1350]:122)
at std::panicking::begin_panic_fmt::h991e7d1ca9bf9c0c (wasm-function[1351]:95)
at wasm::fail::ha4c23c69dfa0eea9 (wasm-function[88]:477)
at core::ops::function::FnOnce::call_once::h633718dad359559a (wasm-function[21]:22)
at wasm_bindgen_test::__rt::Context::execute::h2f669104986475eb (wasm-function[13]:291)
at __wbg_test_fail_1 (wasm-function[87]:57)
at module.exports.__wbg_apply_2ba774592c5223a7 (/home/alex/code/wasm-bindgen/target/wasm32-unknown-unknown/wbg-tmp/wasm-4a309ffe6ad80503.js:61:66)
failures:
wasm::fail
test result: FAILED. 1 passed; 1 failed; 0 ignored
error: test failed, to rerun pass '--test wasm'
```
And that's it! You've now got a test harness executing native wasm code inside
of Node.js and you can use `cargo test` as you normally would for workflows.
## Components
The test harness is made of three separate components, but you typically don't
have to worry about most of them. They're documented here for documentation
purposes!
### `wasm-bindgen-test-macro`
This crate, living at `crates/test-macro`, is a procedural macro that defines
the `#[wasm_bindgen_test]` macro. **The normal `#[test]` cannot be used and will
not work.** Eventually it's intended that the `#[wasm_bindgen_test]` attribute
could gain arguments like "run in a browser" or something like a minimum Node
version.
For now though the macro is pretty simple and reexported from the next crate,
`wasm-bindgen-test`.
### `wasm-bindgen-test`
This is the runtime support needed to execute tests. This is basically the same
thing as the `test` crate in the Rust repository, and one day it will likely use
the `test` crate itself! For now though it's a minimal reimplementation that
provides the support for:
* Printing what test cases are running
* Collecting `console.log` and `console.error` output of each test case for
printing later
* Rendering the failure output of each test case
* Catching JS exceptions so tests can continue to run after a test fails
* Driving execution of all tests
This is the crate which you actually link to in your wasm test and through which
you import the `#[wasm_bindgen_test]` macro. Otherwise this crate provides a
`console_log!` macro that's a utility like `println!` only using `console.log`.
This crate may grow more functionality in the future, but for now it's somewhat
bare bones!
### `wasm-bindgen-test-runner`
This is where the secret sauce comes into play. We configured Cargo to execute
this binary *instead* of directly executing the `*.wasm` file (which Cargo would
otherwise try to do). This means that whenever a test is executed it executes
this binary with the wasm file as an argument, allowing it to take full control
over the test process!
The test runner is currently pretty simple, executing a few steps:
* First, it runs the equivalent of `wasm-bindgen`. This'll generate wasm-bindgen
output in a temoprary directory.
* Next, it generates a small shim JS file which imports these
wasm-bindgen-generated files and executes the test harness.
* Finally, it executes `node` over the generated JS file, executing all of your
tests.
In essence what happens is that this test runner automatically executes
`wasm-bindgen` and then uses Node to actually execute the wasm file, meaning
that your wasm code currently runs in a Node environment.
## Future Work
Things that'd be awesome to support in the future:
* Arguments to `wasm-bindgen-test-runner` which are the same as `wasm-bindgen`,
for example `--debug` to affect the generated output.
* Built-in webserver to `wasm-bindgen-test-runner`. This would be handy for
running tests in a browser while developing.
* Headless browser testing to allow for testing in a browser on CI.
* Running each test in its own wasm instance to avoid poisoning the environment
on panic

29
crates/test/out.sh Normal file
View File

@@ -0,0 +1,29 @@
rustc \
+nightly \
--crate-name \
wasm_bindgen_test_runner \
crates/test-runner/src/main.rs \
--crate-type \
bin \
--emit=dep-info,link \
-C \
opt-level=s \
-C \
panic=abort \
-C \
lto \
-C \
metadata=de5c24b259631256 \
-C \
extra-filename=-de5c24b259631256 \
--out-dir \
/home/alex/code/wasm-bindgen/target/release/deps \
-L \
dependency=/home/alex/code/wasm-bindgen/target/release/deps \
--extern \
failure=/home/alex/code/wasm-bindgen/target/release/deps/libfailure-7c7642ad9a5ea78f.rlib \
--extern \
wasm_bindgen_cli_support=/home/alex/code/wasm-bindgen/target/release/deps/libwasm_bindgen_cli_support-319f8cb472c7d7e6.rlib \
-L \
native=/home/alex/code/wasm-bindgen/target/release/build/backtrace-sys-219bc8940e273b6b/out \
-Z time-passes

25
crates/test/src/lib.rs Normal file
View File

@@ -0,0 +1,25 @@
//! Runtime support for the `#[wasm_bindgen_test]` attribute
//!
//! More documentation can be found in the README for this crate!
#![feature(use_extern_macros, wasm_import_module)]
extern crate wasm_bindgen_test_macro;
extern crate wasm_bindgen;
extern crate js_sys;
extern crate console_error_panic_hook;
pub use wasm_bindgen_test_macro::wasm_bindgen_test;
/// Helper macro which acts like `println!` only routes to `console.log`
/// instead.
#[macro_export]
macro_rules! console_log {
($($arg:tt)*) => (
$crate::__rt::log(&format_args!($($arg)*))
)
}
#[path = "rt.rs"]
#[doc(hidden)]
pub mod __rt;

237
crates/test/src/rt.rs Normal file
View File

@@ -0,0 +1,237 @@
use std::cell::{RefCell, Cell};
use std::fmt;
use std::mem;
use console_error_panic_hook;
use js_sys::Array;
use wasm_bindgen::prelude::*;
/// Runtime test harness support instantiated in JS.
///
/// The node.js entry script instantiates a `Context` here which is used to
/// drive test execution.
#[wasm_bindgen]
pub struct Context {
filter: Option<String>,
current_test: RefCell<Option<String>>,
succeeded: Cell<usize>,
ignored: Cell<usize>,
failures: RefCell<Vec<(String, String)>>,
current_log: RefCell<String>,
current_error: RefCell<String>,
ignore_this_test: Cell<bool>,
}
#[wasm_bindgen]
extern {
// Redefined from `js_sys` so we can catch the error
pub type Function;
#[wasm_bindgen(method, catch)]
fn apply(this: &Function, new_this: &JsValue, args: &Array) -> Result<JsValue, JsValue>;
#[wasm_bindgen(js_namespace = console, js_name = log)]
#[doc(hidden)]
pub fn console_log(s: &str);
// Not using `js_sys::Error` because node's errors specifically have a
// `stack` attribute.
type NodeError;
#[wasm_bindgen(method, getter, js_class = "Error", structural)]
fn stack(this: &NodeError) -> String;
// General-purpose conversion into a `String`.
#[wasm_bindgen(js_name = String)]
fn stringify(val: &JsValue) -> String;
}
#[wasm_bindgen(module = "fs", version = "*")]
extern {
fn writeSync(fd: i32, data: &[u8]);
}
pub fn log(args: &fmt::Arguments) {
console_log(&args.to_string());
}
#[wasm_bindgen]
impl Context {
#[wasm_bindgen(constructor)]
pub fn new() -> Context {
console_error_panic_hook::set_once();
Context {
filter: None,
current_test: RefCell::new(None),
succeeded: Cell::new(0),
ignored: Cell::new(0),
failures: RefCell::new(Vec::new()),
current_log: RefCell::new(String::new()),
current_error: RefCell::new(String::new()),
ignore_this_test: Cell::new(false),
}
}
/// Inform this context about runtime arguments passed to the test
/// harness.
///
/// Eventually this will be used to support flags, but for now it's just
/// used to support test filters.
pub fn args(&mut self, args: Vec<JsValue>) {
for arg in args {
let arg = arg.as_string().unwrap();
if arg.starts_with("-") {
panic!("flag {} not supported", arg);
} else if self.filter.is_some() {
panic!("more than one filter argument cannot be passed");
}
self.filter = Some(arg);
}
}
/// Executes a list of tests, returning whether any of them failed.
///
/// This is the main entry point for executing tests. All the tests passed
/// in are the JS `Function` object that was plucked off the
/// `WebAssembly.Instance` exports list. This allows us to invoke it but
/// still catch JS exceptions.
pub fn run(&self, tests: Vec<JsValue>) -> bool {
let this = JsValue::null();
let args = Array::new();
args.push(JsValue::from(self as *const Context as u32));
let noun = if tests.len() == 1 { "test" } else { "tests" };
console_log!("running {} {}", tests.len(), noun);
console_log!("");
for test in tests {
self.ignore_this_test.set(false);
let test = Function::from(test);
match test.apply(&this, &args) {
Ok(_) => {
if self.ignore_this_test.get() {
self.log_ignore()
} else {
self.log_success()
}
}
Err(e) => self.log_error(e.into()),
}
drop(self.current_test.borrow_mut().take());
*self.current_log.borrow_mut() = String::new();
*self.current_error.borrow_mut() = String::new();
}
self.log_results();
self.failures.borrow().len() == 0
}
fn log_start(&self, test: &str) {
let mut current_test = self.current_test.borrow_mut();
assert!(current_test.is_none());
*current_test = Some(test.to_string());
let data = format!("test {} ... ", test);
writeSync(2, data.as_bytes());
}
fn log_success(&self) {
writeSync(2, b"ok\n");
self.succeeded.set(self.succeeded.get() + 1);
}
fn log_ignore(&self) {
writeSync(2, b"ignored\n");
self.ignored.set(self.ignored.get() + 1);
}
fn log_error(&self, err: NodeError) {
writeSync(2, b"FAILED\n");
let name = self.current_test.borrow().as_ref().unwrap().clone();
let log = mem::replace(&mut *self.current_log.borrow_mut(), String::new());
let error = mem::replace(&mut *self.current_error.borrow_mut(), String::new());
let mut msg = String::new();
if log.len() > 0 {
msg.push_str("log output:\n");
msg.push_str(&tab(&log));
msg.push_str("\n");
}
if error.len() > 0 {
msg.push_str("error output:\n");
msg.push_str(&tab(&error));
msg.push_str("\n");
}
msg.push_str("JS exception that was thrown:\n");
msg.push_str(&tab(&err.stack()));
self.failures.borrow_mut().push((name, msg));
}
fn log_results(&self) {
let failures = self.failures.borrow();
if failures.len() > 0 {
console_log!("\nfailures:\n");
for (test, logs) in failures.iter() {
console_log!("---- {} output ----\n{}\n", test, tab(logs));
}
console_log!("failures:\n");
for (test, _) in failures.iter() {
console_log!(" {}\n", test);
}
} else {
console_log!("");
}
console_log!(
"test result: {}. \
{} passed; \
{} failed; \
{} ignored\n",
if failures.len() == 0 { "ok" } else { "FAILED" },
self.succeeded.get(),
failures.len(),
self.ignored.get(),
);
}
pub fn console_log(&self, original: &Function, args: &Array) {
self.log(original, args, &self.current_log)
}
pub fn console_error(&self, original: &Function, args: &Array) {
self.log(original, args, &self.current_error)
}
fn log(&self, orig: &Function, args: &Array, dst: &RefCell<String>) {
if self.current_test.borrow().is_none() {
drop(orig.apply(&JsValue::null(), args));
return
}
let mut log = dst.borrow_mut();
args.for_each(&mut |val, idx, _array| {
if idx != 0 {
log.push_str(" ");
}
log.push_str(&stringify(&val));
});
log.push_str("\n");
}
}
impl Context {
pub fn execute(&self, name: &str, f: impl FnOnce()) {
self.log_start(name);
if let Some(filter) = &self.filter {
if !name.contains(filter) {
self.ignore_this_test.set(true);
return
}
}
f();
}
}
fn tab(s: &str) -> String {
let mut result = String::new();
for line in s.lines() {
result.push_str(" ");
result.push_str(line);
result.push_str("\n");
}
return result;
}