ps-blitz-script 0.4.3

JavaScript execution for Blitz using the Boa engine
Documentation 
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! `document.implementation.createHTMLDocument`.
//!
//! jQuery runs this during initialisation, before it assigns itself to
//! `window`:
//!
//! ```js
//! le.createHTMLDocument = ((Jt = C.implementation.createHTMLDocument("").body)
//!     .innerHTML = "<form></form><form></form>", 2 === Jt.childNodes.length)
//! ```
//!
//! `document.implementation` is `undefined`, so reading `createHTMLDocument`
//! off it throws `TypeError: cannot convert 'null' or 'undefined' to object`
//! and the library never defines `jQuery`. Every site hitting it reports the
//! downstream symptom, `jQuery is not defined` — a global that was never
//! missing — which is why the cause went unranked for so long.
//!
//! These tests are the three lines of that feature-detect and nothing else.
//! Loading the real library to prove the same thing means carrying 87KB of
//! minified script to assert `childNodes.length == 2`.

use blitz_script::ScriptDocument;

fn value(doc: &mut ScriptDocument, expression: &str) -> serde_json::Value {
    doc.eval_json(expression).unwrap_or(serde_json::Value::Null)
}

fn page() -> ScriptDocument {
    ScriptDocument::from_html(
        "<html><body><div id='host'></div></body></html>",
        blitz_dom::DocumentConfig::default(),
    )
}

/// `document.implementation` exists.
#[test]
fn implementation_is_an_object() {
    let mut doc = page();
    doc.execute_scripts();
    assert_eq!(value(&mut doc, "typeof document.implementation"), "object");
}

/// It carries `createHTMLDocument`.
#[test]
fn create_html_document_is_callable() {
    let mut doc = page();
    doc.execute_scripts();
    assert_eq!(
        value(
            &mut doc,
            "typeof document.implementation.createHTMLDocument"
        ),
        "function"
    );
}

/// The returned document has a `body`, and it is not this document's body.
///
/// `document.body` resolves by searching for the first `body` in the tree
/// rather than within the document it was asked of, so a second document is
/// exactly the case that catches it. A `createHTMLDocument` that returned the
/// live page's body would pass a test that only checked `body` was non-null,
/// and would then let jQuery scribble two `<form>` elements into the page.
#[test]
fn the_new_document_has_its_own_body() {
    let mut doc = page();
    doc.execute_scripts();

    assert_eq!(
        value(
            &mut doc,
            "(function () {\
               var d = document.implementation.createHTMLDocument('');\
               return d.body ? 'present' : 'missing';\
             })()"
        ),
        "present"
    );
    assert_eq!(
        value(
            &mut doc,
            "(function () {\
               var d = document.implementation.createHTMLDocument('');\
               return d.body === document.body;\
             })()"
        ),
        false,
        "the new document handed back the live page's body"
    );
}

/// The title argument is applied.
#[test]
fn the_title_argument_is_used() {
    let mut doc = page();
    doc.execute_scripts();
    assert_eq!(
        value(
            &mut doc,
            "document.implementation.createHTMLDocument('hello').title"
        ),
        "hello"
    );
}

/// jQuery's feature-detect, exactly.
///
/// This is the assertion the whole thing exists for: two `<form>` elements
/// parsed into the new document's body come back as two children. jQuery reads
/// the result to decide whether it can use `createHTMLDocument` for parsing.
#[test]
fn the_jquery_feature_detect_answers_two() {
    let mut doc = page();
    doc.execute_scripts();
    assert_eq!(
        value(
            &mut doc,
            "(function () {\
               var b = document.implementation.createHTMLDocument('').body;\
               b.innerHTML = '<form></form><form></form>';\
               return b.childNodes.length;\
             })()"
        ),
        2
    );
}

/// Writing into the new document does not touch the live one.
///
/// The same arena backs both, so this is the failure mode to guard: a
/// `createHTMLDocument` implemented by appending to the real tree would pass
/// every test above and corrupt the page.
#[test]
fn the_live_document_is_untouched() {
    let mut doc = page();
    doc.execute_scripts();
    assert_eq!(
        value(
            &mut doc,
            "(function () {\
               var before = document.body.childNodes.length;\
               var b = document.implementation.createHTMLDocument('').body;\
               b.innerHTML = '<form></form><form></form>';\
               return document.body.childNodes.length === before;\
             })()"
        ),
        true,
        "creating a document changed the live page"
    );
}