wasm_bindgen_test/rt/
worker.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//! Support for printing status information of a test suite in a browser.
//!
//! Currently this is quite simple, rendering the same as the console tests in
//! node.js. Output here is rendered in a `pre`, however.

use js_sys::Error;
use wasm_bindgen::prelude::*;

use super::TestResult;

/// Implementation of `Formatter` for browsers.
///
/// Routes all output to a `pre` on the page currently. Eventually this probably
/// wants to be a pretty table with colors and folding and whatnot.
pub struct Worker {}

#[wasm_bindgen]
extern "C" {
    type WorkerError;
    #[wasm_bindgen(method, getter, structural)]
    fn stack(this: &WorkerError) -> JsValue;

    #[wasm_bindgen(js_name = "__wbg_test_output_writeln")]
    fn write_output_line(data: JsValue);
}

impl Worker {
    /// Attempts to create a new formatter for web worker
    pub fn new() -> Worker {
        Worker {}
    }
}

impl super::Formatter for Worker {
    fn writeln(&self, line: &str) {
        write_output_line(JsValue::from(String::from(line)));
    }

    fn log_test(&self, name: &str, result: &TestResult) {
        self.writeln(&format!("test {} ... {}", name, result));
    }

    fn stringify_error(&self, err: &JsValue) -> String {
        // TODO: this should be a checked cast to `Error`
        let error = Error::from(err.clone());
        let name = String::from(error.name());
        let message = String::from(error.message());
        let err = WorkerError::from(err.clone());
        let stack = err.stack();

        let header = format!("{}: {}", name, message);
        let stack = match stack.as_string() {
            Some(stack) => stack,
            None => return header,
        };

        // If the `stack` variable contains the name/message already, this is
        // probably a chome-like error which is already rendered well, so just
        // return this info
        if stack.contains(&header) {
            return stack;
        }

        // Fallback to make sure we don't lose any info
        format!("{}\n{}", header, stack)
    }
}