mirror of
https://github.com/fluencelabs/wasm-bindgen
synced 2025-06-28 20:21:35 +00:00
Update test harness for browser testing
This commit updates the test harness for in-browser testing. It now no longer unconditionally uses `fs.writeSync`, for example. Instead a `Formatter` trait is introduced for both Node/browser environments and at runtime we detect which is the appropriate one to use.
This commit is contained in:
Alex Crichton
240
crates/test/src/rt/mod.rs
Normal file
240
crates/test/src/rt/mod.rs
Normal file
@ -0,0 +1,240 @@
|
||||
#![doc(hidden)]
|
||||
|
||||
use std::cell::{RefCell, Cell};
|
||||
use std::fmt;
|
||||
use std::mem;
|
||||
|
||||
use console_error_panic_hook;
|
||||
use js_sys::{Array, Function};
|
||||
use wasm_bindgen::prelude::*;
|
||||
|
||||
pub mod node;
|
||||
pub mod browser;
|
||||
pub mod detect;
|
||||
|
||||
/// 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>,
|
||||
formatter: Box<Formatter>,
|
||||
}
|
||||
|
||||
trait Formatter {
|
||||
fn writeln(&self, line: &str);
|
||||
fn log_start(&self, name: &str);
|
||||
fn log_success(&self);
|
||||
fn log_ignored(&self);
|
||||
fn log_failure(&self, err: JsValue) -> String;
|
||||
}
|
||||
|
||||
#[wasm_bindgen]
|
||||
extern {
|
||||
#[wasm_bindgen(js_namespace = console, js_name = log)]
|
||||
#[doc(hidden)]
|
||||
pub fn console_log(s: &str);
|
||||
|
||||
// General-purpose conversion into a `String`.
|
||||
#[wasm_bindgen(js_name = String)]
|
||||
fn stringify(val: &JsValue) -> String;
|
||||
}
|
||||
|
||||
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();
|
||||
|
||||
let formatter = match node::Node::new() {
|
||||
Some(node) => Box::new(node) as Box<Formatter>,
|
||||
None => Box::new(browser::Browser::new()),
|
||||
};
|
||||
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),
|
||||
formatter,
|
||||
}
|
||||
}
|
||||
|
||||
/// 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" };
|
||||
self.formatter.writeln(&format!("running {} {}", tests.len(), noun));
|
||||
self.formatter.writeln("");
|
||||
|
||||
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_failure(e),
|
||||
}
|
||||
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());
|
||||
self.formatter.log_start(test);
|
||||
}
|
||||
|
||||
fn log_success(&self) {
|
||||
self.formatter.log_success();
|
||||
self.succeeded.set(self.succeeded.get() + 1);
|
||||
}
|
||||
|
||||
fn log_ignore(&self) {
|
||||
self.formatter.log_ignored();
|
||||
self.ignored.set(self.ignored.get() + 1);
|
||||
}
|
||||
|
||||
fn log_failure(&self, err: JsValue) {
|
||||
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(&self.formatter.log_failure(err)));
|
||||
self.failures.borrow_mut().push((name, msg));
|
||||
}
|
||||
|
||||
fn log_results(&self) {
|
||||
let failures = self.failures.borrow();
|
||||
if failures.len() > 0 {
|
||||
self.formatter.writeln("\nfailures:\n");
|
||||
for (test, logs) in failures.iter() {
|
||||
let msg = format!("---- {} output ----\n{}", test, tab(logs));
|
||||
self.formatter.writeln(&msg);
|
||||
}
|
||||
self.formatter.writeln("failures:\n");
|
||||
for (test, _) in failures.iter() {
|
||||
self.formatter.writeln(&format!(" {}", test));
|
||||
}
|
||||
}
|
||||
self.formatter.writeln("");
|
||||
self.formatter.writeln(&format!(
|
||||
"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;
|
||||
}
|
||||
Reference in New Issue
Block a user