Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / html / scripting / tests_scenarios.lucb

#==============================================================================================
#
#   tests_scenarios - end-to-end paths the scripting environments unblock (region r29)
#
#   DESCRIPTION:
#       The paths regions r17 and r19 left for this region: an Event made by its real
#       constructor (its time stamp reads the relevant global object's settings), dispatched
#       through a node tree to native listeners (each call prepares to run script and a callback
#       in the listener's realm and cleans up after, ending in a microtask checkpoint), and a
#       document's readiness change firing readystatechange at the document. They run in a
#       principal realm of tests_environments (a test global and settings object); the
#       documents and elements are r17's and r18's test nodes.
#
#==============================================================================================

# mark: Helpers =================================================================================

## What a native test listener records.
struct TestHtmlListener:
    var log: TestHtmlLog*
    var number: i32
    var realm: Realm*
    var stop_propagation: bool
    var saw_wrong_realm: bool
    var last_event_type: ak.FlyString

## The behaviour of a native test listener: logs its number, checks that the listener's realm is
## the current realm (prepare to run script pushed it), and optionally stops propagation.
func test_html_listener_call(context: void*?, vm: Vm*) -> JsValue!:
    let listener = (TestHtmlListener*)(context else trap("no captures"))
    let event = as_dom_event((gc.Cell*)js_value_as_object(vm_argument(vm, 0)))
    listener.log.entries[listener.log.count] = listener.number
    listener.log.count += 1
    if vm_current_realm(vm) != listener.realm:
        listener.saw_wrong_realm = true
    listener.last_event_type = dom_event_type(event)
    if listener.stop_propagation:
        dom_event_stop_propagation(event)
    return js_undefined()

## An IDLEventListener over a native function, made as C++'s native listeners are made:
## NativeFunction::create, CallbackType (whose callback context is the realm's principal settings
## object) and IDLEventListener::create.
func test_html_native_listener(realm: Realm*, listener: TestHtmlListener*) -> DomIdlEventListener*:
    let function = js_native_function_create(realm, JsNativeFunctionBehaviour(call = test_html_listener_call, context = listener), 1, ak.utf16_fly_string_new(), realm)
    let callback = realm_create_idl_callback_type_realm(realm, (JsObject*)function, realm, IdlOperationReturnsPromise.no)
    return dom_idl_event_listener_create(realm, callback)

## A recording listener `number` of `realm` (the captures live in the test's memory).
func test_html_listener(realm: Realm*, log: TestHtmlLog*, number: i32, stop_propagation: bool = false) -> TestHtmlListener*:
    return new TestHtmlListener(log = log, number = number, realm = realm, stop_propagation = stop_propagation, saw_wrong_realm = false, last_event_type = ak.FlyString()) else trap("out of memory")

# mark: Dispatch ================================================================================

test "an event made by its constructor dispatches through a node tree to native listeners":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let event_loop = html_main_thread_event_loop()
    let document = test_html_heap_document(realm)
    let parent = test_realm_element(realm, document, "div")
    let child = test_realm_element(realm, document, "span")
    tree_node_append_child(document.dom_node(), parent.dom_node())
    tree_node_append_child(parent.dom_node(), child.dom_node())

    var log = TestHtmlLog()
    let type_ = ak.fly_string_from_str("custom")
    let capturing = test_html_listener(realm, &log, 1)
    let at_target = test_html_listener(realm, &log, 2)
    let once = test_html_listener(realm, &log, 5)
    let bubbling = test_html_listener(realm, &log, 3)
    let on_document = test_html_listener(realm, &log, 4)
    dom_event_target_add_event_listener(parent.dom_event_target(), type_, test_html_native_listener(realm, capturing), test_add_options(capture = true))
    dom_event_target_add_event_listener(child.dom_event_target(), type_, test_html_native_listener(realm, at_target), test_add_options())
    dom_event_target_add_event_listener(child.dom_event_target(), type_, test_html_native_listener(realm, once), test_add_options(once = true))
    dom_event_target_add_event_listener(parent.dom_event_target(), type_, test_html_native_listener(realm, bubbling), test_add_options())
    dom_event_target_add_event_listener(document.dom_event_target(), type_, test_html_native_listener(realm, on_document), test_add_options())

    # The constructor's time stamp is the current high resolution time relative to the time
    # origin (1000ms after the monotonic clock's zero in the test settings object).
    let before = high_resolution_time_unsafe_shared_current_time()
    let event = dom_event_create(realm, type_, DomEventInit(bubbles = true))
    let after = high_resolution_time_unsafe_shared_current_time()
    assert(dom_event_time_stamp(event) >= high_resolution_time_coarsen_time(before) - 1000.0)
    assert(dom_event_time_stamp(event) <= after - 1000.0)
    assert(event.m_is_trusted)

    # Capture at the parent, the target's listeners in order, then bubbling up to the document.
    assert(dom_event_target_dispatch_event(child.dom_event_target(), event))
    assert(test_html_log_is(&log, [1, 2, 5, 3, 4]))
    assert(dom_event_event_phase(event) == 0 and dom_event_current_target(event) == none)
    assert(test_fly_is(on_document.last_event_type, "custom"))

    # Every call ran in the listener's realm and cleaned up after itself.
    assert(not capturing.saw_wrong_realm and not at_target.saw_wrong_realm and not on_document.saw_wrong_realm)
    assert(vm_execution_context_stack(vm).length == 0)
    assert(html_event_loop_is_backup_incumbent_realm_stack_empty(event_loop))

    # The once listener is gone; a non-bubbling event stops at the target.
    log = TestHtmlLog()
    assert(dom_event_target_dispatch_event(child.dom_event_target(), dom_event_create(realm, type_)))
    assert(test_html_log_is(&log, [1, 2]))

    # stopPropagation() in the capturing listener stops the dispatch after the parent.
    log = TestHtmlLog()
    capturing.stop_propagation = true
    assert(dom_event_target_dispatch_event(child.dom_event_target(), dom_event_create(realm, type_, DomEventInit(bubbles = true))))
    assert(test_html_log_is(&log, [1]))

test "a listener's microtask runs at the checkpoint after the listener returns":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let document = test_html_heap_document(realm)
    let element = test_realm_element(realm, document, "div")
    tree_node_append_child(document.dom_node(), element.dom_node())

    var log = TestHtmlLog()
    let type_ = ak.fly_string_from_str("ping")
    dom_event_target_add_event_listener(element.dom_event_target(), type_, test_html_native_listener(realm, test_html_listener(realm, &log, 1)), test_add_options())
    # The microtask is queued before the dispatch; it waits for the first checkpoint, which the
    # clean-up after the listener performs once the execution context stack is empty.
    html_queue_a_microtask(none, test_html_log_steps(vm, &log, 2))
    assert(dom_event_target_dispatch_event(element.dom_event_target(), dom_event_create(realm, type_)))
    assert(test_html_log_is(&log, [1, 2]))

# mark: Readiness ===============================================================================

test "Document::update_readiness fires readystatechange at the document":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    html_event_names_readystatechange = ak.fly_string_from_str("readystatechange")
    let document = test_html_heap_document(realm)
    document.m_readiness = HtmlDocumentReadyState.loading

    var log = TestHtmlLog()
    let listener = test_html_listener(realm, &log, 1)
    dom_event_target_add_event_listener(document.dom_event_target(), html_event_names_readystatechange, test_html_native_listener(realm, listener), test_add_options())

    dom_document_update_readiness(document, HtmlDocumentReadyState.interactive)
    assert(test_sv_is(dom_document_ready_state(document), "interactive"))
    assert(test_html_log_is(&log, [1]))
    assert(test_fly_is(listener.last_event_type, "readystatechange"))
    assert(test_document_client_log.frames_requested == 1)

    # The same readiness again fires nothing.
    dom_document_update_readiness(document, HtmlDocumentReadyState.interactive)
    assert(log.count == 1)

    # Complete: without a traversable navigable, page_did_load waits for one.
    dom_document_update_readiness(document, HtmlDocumentReadyState.complete)
    assert(test_html_log_is(&log, [1, 1]))
    assert(document.m_needs_to_call_page_did_load)
    assert(vm_execution_context_stack(vm).length == 0)