Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / fetch / fetching / tests_fetching_1.lucb

#==============================================================================================
#
#   tests_fetching_1 - Fetch/Fetching's checks pinned to the reference build; PendingResponse,
#   RefCountedFlag, the HTTP cache partitions, Mixed Content, and the Error and
#   TransformStream stand-ins
#
#   DESCRIPTION:
#       The runner of tests_fetching_cases (the CORS check, the TAO check and the Fetch metadata
#       headers over 507 cases, printed as the reference build's oracle prints them), and the
#       parts of region p2c the scenarios of tests_fetching_2 and _3 do not single out:
#       PendingResponse's callback (set before or after the response, run on a later turn,
#       the request forgetting it), RefCountedFlag, HTTPCache's caches per network partition
#       key (its keys copied to the C heap, DESIGN.md ยง3.3 rule 7), the memory cache off by
#       default, Mixed Content's checks for a non-Window settings object, the TypeError
#       stand-in, the TransformStream stand-in piping a byte stream through an identity
#       transform, and what the region's cells keep alive through a collection.
#
#==============================================================================================

# mark: The oracle's cases ======================================================================

## The oracle's `credentials_of`.
func fetching_test_credentials(argument: ak.StringView) -> FetchRequestCredentialsMode:
    if ak.string_view_equals(&argument, "omit"):
        return FetchRequestCredentialsMode.omit
    if ak.string_view_equals(&argument, "same-origin"):
        return FetchRequestCredentialsMode.same_origin
    return FetchRequestCredentialsMode.include

## Runs one case and appends its result as the oracle prints it.
func fetching_test_run_case(builder: ak.StringBuilder*, vm: Vm*, test_case: const FetchHttpCase*):
    let vector = fetch_http_test_arguments(test_case)
    let a = ak.vector_span_const(&vector)
    let op = test_case.op
    if op == "cors_check":
        let request = fetch_request_create(vm)
        fetch_request_set_credentials_mode(request, fetching_test_credentials(a[0]))
        fetch_request_set_origin(request, fetch_http_test_origin(a[1]))
        let response = fetch_infrastructure_test_response_with_headers(vm, a, 2)
        ak.string_builder_append(builder, "success" if fetch_fetching_cors_check(request, response) else "failure")
    elif op == "tao_check":
        let request = fetch_request_create(vm)
        fetch_request_set_timing_allow_failed(request, ak.string_view_equals(&a[0], "true"))
        fetch_request_set_mode(request, fetch_http_test_mode(a[1]))
        fetch_request_set_origin(request, fetch_http_test_origin(a[2]))
        fetch_request_set_url(request, fetch_http_test_url(a[3]))
        fetch_request_set_response_tainting(request, fetch_http_test_tainting(a[4]))
        let response = fetch_infrastructure_test_response_with_headers(vm, a, 5)
        ak.string_builder_append(builder, "success" if fetch_fetching_tao_check(request, response) else "failure")
    elif op == "fetch_metadata":
        let request = fetch_request_create(vm)
        fetch_request_set_origin(request, fetch_http_test_origin(a[0]))
        fetch_request_set_mode(request, fetch_http_test_mode(a[1]))
        fetch_request_set_destination(request, fetch_infrastructure_test_destination(a[2]))
        fetch_request_set_user_activation(request, ak.string_view_equals(&a[3], "true"))
        fetch_request_set_url_list(request, fetch_http_test_url_list(a, 4))
        fetch_fetching_append_fetch_metadata_headers_for_request(request)
        fetch_http_test_headers(builder, http_header_list_headers(fetch_request_header_list(request)))
    else:
        trap("unknown op")

test "Fetch/Fetching's CORS and TAO checks and Fetch metadata headers give the reference build's results":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    var failures = 0
    with allocator:
        for test_case in &fetch_fetching_cases:
            var builder = ak.string_builder_new()
            fetching_test_run_case(&builder, vm, test_case)
            let result = ak.string_builder_string_view(&builder)
            if not ak.string_view_eq_string_view(&result, ak.string_view_from_bytes(test_case.expected)):
                var arguments = ak.string_builder_new()
                fetch_http_test_escape(&arguments, ak.string_view_from_bytes(test_case.arguments))
                print(f"{test_case.op} {ak.string_view_text(ak.string_builder_string_view(&arguments))}:\n  expected {(str)test_case.expected}\n  got      {ak.string_view_text(result)}")
                failures += 1
    assert(failures == 0)

# mark: PendingResponse and RefCountedFlag ======================================================

## What a PendingResponse callback heard.
struct FetchingTestCallbackLog:
    var calls: i32
    var response: FetchResponse*?

    ## The callback.
    static func call(context: void*?, response: FetchResponse*):
        let log = (FetchingTestCallbackLog*)(context else trap("no log"))
        log.calls += 1
        log.response = response

## Whether a request still lists `pending_response`.
func fetching_test_is_pending(request: FetchRequest*, pending_response: FetchPendingResponse*) -> bool:
    for pending in ak.vector_span(&request.m_pending_responses):
        if pending == pending_response:
            return true
    return false

test "PendingResponse: the callback runs on a later turn once both are known; the request lists it until then":
    var event_loop = FetchingTestEventLoop()
    fetching_test_begin(&event_loop)
    defer fetching_test_end()
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    _ = web_test_install_agent(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let request = fetch_request_create(vm)
        let response = fetch_infrastructure_response_create(vm)

        # The callback first: resolve runs it on the next turn.
        let pending = fetch_pending_response_create(vm, request)
        assert(not fetch_pending_response_is_resolved(pending) and fetching_test_is_pending(request, pending))
        let log = new FetchingTestCallbackLog() else trap("out of memory")
        fetch_pending_response_when_loaded(pending, ak.Function1[FetchResponse*, unit](call = FetchingTestCallbackLog.call, context = log))
        assert(log.calls == 0)
        fetch_pending_response_resolve(pending, response)
        assert(fetch_pending_response_is_resolved(pending) and log.calls == 0)
        fetching_test_run(&event_loop)
        assert(log.calls == 1 and log.response == response)
        assert(not fetching_test_is_pending(request, pending))

        # The response first (created resolved): when_loaded runs it on the next turn.
        let resolved = fetch_pending_response_create_fetch_response(vm, request, response)
        assert(fetch_pending_response_is_resolved(resolved) and fetching_test_is_pending(request, resolved))
        let second = new FetchingTestCallbackLog() else trap("out of memory")
        fetch_pending_response_when_loaded(resolved, ak.Function1[FetchResponse*, unit](call = FetchingTestCallbackLog.call, context = second))
        assert(second.calls == 0)
        fetching_test_run(&event_loop)
        assert(second.calls == 1 and second.response == response and not fetching_test_is_pending(request, resolved))

        # RefCountedFlag holds its value.
        let flag = fetch_ref_counted_flag_create(false)
        assert(not fetch_ref_counted_flag_value(flag))
        fetch_ref_counted_flag_set_value(flag, true)
        assert(fetch_ref_counted_flag_value(flag))
        assert(fetch_ref_counted_flag_value(fetch_ref_counted_flag_create(true)))

# mark: HTTP cache partitions ===================================================================

## A network partition key of the origin of `url`.
func fetching_test_partition_key(url: str) -> FetchNetworkPartitionKey:
    let parsed = web_url.parser_basic_parse(ak.sv(url)) else trap("the test URL parses")
    return FetchNetworkPartitionKey(top_level_origin = web_url.url_origin(&parsed), second_key = none)

test "HTTPCache: one memory cache per network partition key, its keys in the C heap; the memory cache is off":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        fetch_fetching_clear_http_memory_cache()
        let cache = fetch_http_cache_the()
        assert(cache == fetch_http_cache_the() and ak.hash_map_is_empty(&cache.m_cache))

        # Keys hash and compare as their top-level origins (Traits<NetworkPartitionKey>).
        var traits = FetchNetworkPartitionKeyTraits()
        let first_key = fetching_test_partition_key("https://a-long-host-name.test/one")
        let same_key = fetching_test_partition_key("https://a-long-host-name.test:443/two")
        let other_key = fetching_test_partition_key("https://b.test/")
        assert(traits.equals(&first_key, &same_key) and not traits.equals(&first_key, &other_key))
        assert(traits.hash_of(&first_key) == web_url.origin_traits_hash(&first_key.top_level_origin))

        # The same key gives the same cache; the stored key survives a collection of the VM's heap.
        let first = fetch_http_cache_get(cache, &first_key)
        gc.heap_collect_garbage(vm_heap(vm))
        assert(fetch_http_cache_get(cache, &same_key) == first)
        assert(fetch_http_cache_get(cache, &other_key) != first)
        assert(ak.hash_map_size(&cache.m_cache) == 2)
        let opaque_key = FetchNetworkPartitionKey(top_level_origin = web_url.origin_create_opaque(), second_key = none)
        let opaque = fetch_http_cache_get(cache, &opaque_key)
        assert(fetch_http_cache_get(cache, &opaque_key) == opaque and ak.hash_map_size(&cache.m_cache) == 3)

        # The memory cache is off unless enabled: finalizing an entry with nothing pending does nothing.
        assert(not fetch_fetching_http_memory_cache_enabled())
        http_memory_cache_finalize_entry(first, web_url.about_blank(), ak.sv("GET"), http_header_list_create(), 200, http_header_list_create(), ak.ByteBuffer())
        fetch_fetching_set_http_memory_cache_enabled(true)
        assert(fetch_fetching_http_memory_cache_enabled())
        fetch_fetching_set_http_memory_cache_enabled(false)

        fetch_fetching_clear_http_memory_cache()
        assert(ak.hash_map_is_empty(&cache.m_cache))

# mark: Mixed Content ===========================================================================

test "Mixed Content: a non-Window settings object with an opaque origin does not restrict mixed content":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let settings = web_test_settings_of(realm)
        assert(mixed_content_does_settings_prohibit_mixed_security_contexts(settings) == MixedContentProhibitsMixedSecurityContexts.does_not_restrict_mixed_security_contexts)

        # An image over http is neither upgraded nor blocked; nor is its response.
        let request = fetch_request_create(vm)
        fetch_request_set_url(request, web_url.parser_basic_parse(ak.sv("http://example.com/a.png")) else trap("the URL parses"))
        fetch_request_set_client(request, settings)
        fetch_request_set_destination(request, FetchRequestDestination.image)
        mixed_content_upgrade_a_mixed_content_request_to_a_potentially_trustworthy_url_if_appropriate(request)
        let url = fetch_request_url(request)
        let scheme = web_url.url_scheme(&url)
        assert(ak.string_eq_string_view(&scheme, ak.sv("http")))
        assert(mixed_content_should_fetching_request_be_blocked_as_mixed_content(request) == FetchRequestOrResponseBlocking.allowed)
        let response = fetch_infrastructure_response_create(vm)
        assert(mixed_content_should_response_to_request_be_blocked_as_mixed_content(request, response) == FetchRequestOrResponseBlocking.allowed)

        # A potentially trustworthy URL or an IP address host returns before the settings object is asked.
        let local = fetch_request_create(vm)
        fetch_request_set_url(local, web_url.parser_basic_parse(ak.sv("http://192.168.0.1/a.png")) else trap("the URL parses"))
        fetch_request_set_destination(local, FetchRequestDestination.image)
        mixed_content_upgrade_a_mixed_content_request_to_a_potentially_trustworthy_url_if_appropriate(local)
        let local_url = fetch_request_url(local)
        let local_scheme = web_url.url_scheme(&local_url)
        assert(ak.string_eq_string_view(&local_scheme, ak.sv("http")))

# mark: The Error and TransformStream stand-ins =================================================

test "the TypeError stand-in: an error object of its realm with its message, as a JS value":
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        let value = js_type_error_create(realm, ak.string_from_str("Load failed: nope"))
        assert(js_value_is_object(value))
        let cell = (gc.Cell*)js_value_as_object(value)
        assert(is_js_error(cell) and is_js_type_error(cell))
        let error_ = as_if_js_error(cell) else trap("an error")
        assert(error_.m_realm == realm)
        let name = js_error_name(error_)
        assert(ak.string_view_equals(&name, "TypeError"))
        let message = js_error_message(error_) else trap("a message")
        assert(ak.utf16_string_base_eq_string_view(&message.utf16_string_base, ak.sv("Load failed: nope")))

        let plain = js_error_create(realm)
        assert(is_js_error(plain) and not is_js_type_error(plain) and js_error_message(plain) == none)
        let plain_name = js_error_name(plain)
        assert(ak.string_view_equals(&plain_name, "Error"))
        let with_message = js_error_create_message(realm, ak.utf16_string_from_str("m"))
        assert(js_error_message(with_message) != none)

        # The error is kept by the value that holds it, and collected without it.
        var root = gc.root_create[JsError](error_)
        gc.heap_collect_garbage(vm_heap(vm))
        assert(gc.root_ptr(&root) == error_)
        gc.root_release(&root)

## The identity transform algorithm of the TransformStream test: enqueue the chunk in the transform stream (as fetch
## response handover's), counting the chunks.
struct FetchingTestTransform:
    var realm: Realm*
    var transform_stream: StreamsTransformStream*?
    var chunks: i32
    var flushes: i32

    ## The transform algorithm.
    static func transform(context: void*?, chunk: JsValue) -> JsPromiseCapability*:
        let captures = (FetchingTestTransform*)(context else trap("no captures"))
        captures.chunks += 1
        let stream = captures.transform_stream else trap("no stream")
        streams_transform_stream_default_controller_enqueue(streams_transform_stream_controller(stream), chunk) else trap("enqueue")
        return idl_create_resolved_promise(captures.realm, js_undefined())

    ## The flush algorithm.
    static func flush(context: void*?) -> JsPromiseCapability*:
        let captures = (FetchingTestTransform*)(context else trap("no captures"))
        captures.flushes += 1
        return idl_create_resolved_promise(captures.realm, js_undefined())

## Whether a ByteBuffer holds exactly `text`.
func fetching_test_bytes_are(bytes: const ak.ByteBuffer*, text: str) -> bool:
    let span = ak.byte_buffer_bytes_const(bytes)
    return span.length == text.length and ak.compare_bytes(span, text.bytes) == 0

## A transform stream of `realm` set up with the test's identity transform and flush algorithms.
func fetching_test_transform_stream(vm: Vm*, realm: Realm*, captures: FetchingTestTransform*) -> StreamsTransformStream*:
    let stream = realm_create_streams_transform_stream(realm, realm)
    captures.transform_stream = stream
    let transform = gc.create_function1(vm_heap(vm), ak.Function1[JsValue, JsPromiseCapability*](call = FetchingTestTransform.transform, context = captures))
    let flush = gc.create_function0(vm_heap(vm), ak.Function0[JsPromiseCapability*](call = FetchingTestTransform.flush, context = captures))
    streams_transform_stream_set_up(stream, transform, flush)
    return stream

test "the TransformStream stand-in: a byte stream piped through an identity transform, its end flushed, its error":
    var event_loop = FetchingTestEventLoop()
    fetching_test_begin(&event_loop)
    defer fetching_test_end()
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    defer web_test_destroy_vm(vm)
    let allocator: memory.Allocator = vm_heap(vm)
    with allocator:
        var settings = test_promise_enter(realm)

        # Chunks before and after the pipe arrive in order on the readable side; the source's end flushes, then
        # closes the readable side.
        let source = test_streams_byte_stream(realm)
        test_streams_enqueue(source, "ab")
        let captures = new FetchingTestTransform(realm = realm) else trap("out of memory")
        let transform = fetching_test_transform_stream(vm, realm, captures)
        let readable = streams_readable_stream_piped_through(source, transform)
        assert(readable == streams_transform_stream_readable(transform) and streams_readable_stream_is_locked(source))
        test_streams_enqueue(source, "cd")
        let reader = streams_readable_stream_get_a_reader(readable) else trap("get_a_reader")
        var read_all = TestStreamsReadAll(error_ = js_undefined())
        test_streams_read_all_bytes(vm, reader, &read_all)
        assert(captures.chunks == 2 and captures.flushes == 0 and read_all.successes == 0)
        streams_readable_stream_close(source)
        # (Leaving the execution context performs a microtask checkpoint.)
        test_promise_leave(settings)
        settings = test_promise_enter(realm)
        assert(captures.flushes == 1 and not streams_readable_stream_is_readable(readable))
        assert(read_all.successes == 1 and fetching_test_bytes_are(&read_all.bytes, "abcd"))

        # An errored source errors the readable side; the flush algorithm does not run.
        let failing = test_streams_byte_stream(realm)
        let failing_captures = new FetchingTestTransform(realm = realm) else trap("out of memory")
        let failing_transform = fetching_test_transform_stream(vm, realm, failing_captures)
        let failing_readable = streams_readable_stream_piped_through(failing, failing_transform)
        let error_ = js_type_error_create(realm, ak.string_from_str("Load failed: test"))
        streams_readable_stream_error(failing, error_)
        test_promise_leave(settings)
        assert(streams_readable_stream_is_errored(failing_readable) and failing_captures.flushes == 0)

# mark: Collections =============================================================================

## Weak references to the cells a collection must keep through region p2c's cells.
struct FetchingTestKept:
    var request: gc.Weak[FetchRequest]
    var callback: gc.Weak[gc.Function1[FetchResponse*, unit]]
    var response: gc.Weak[FetchResponse]
    var fetch_params: gc.Weak[FetchParams]
    var stream: gc.Weak[StreamsReadableStream]
    var transform_readable: gc.Weak[StreamsReadableStream]
    var transform_controller: gc.Weak[StreamsTransformStreamDefaultController]

## Makes the cells, rooted only through a pending response, a data receiver and a transform stream.
noinline func make_fetching_test_kept(vm: Vm*, realm: Realm*, pending_root: gc.Root[FetchPendingResponse]*, receiver_root: gc.Root[FetchFetchedDataReceiver]*, transform_root: gc.Root[StreamsTransformStream]*) -> FetchingTestKept:
    let request = fetch_request_create(vm)
    let pending = fetch_pending_response_create(vm, request)
    let log = new FetchingTestCallbackLog() else trap("out of memory")
    fetch_pending_response_when_loaded(pending, ak.Function1[FetchResponse*, unit](call = FetchingTestCallbackLog.call, context = log))
    let response = fetch_infrastructure_response_create(vm)
    pending.m_response = response
    *pending_root = gc.root_create(pending)

    let fetch_params = fetch_params_create(vm, fetch_request_create(vm), fetch_timing_info_create(vm))
    let settings = test_promise_enter(realm)
    let stream = test_streams_byte_stream(realm)
    let receiver = realm_create_fetch_fetched_data_receiver(realm, fetch_params, stream, none)
    *receiver_root = gc.root_create(receiver)

    let captures = new FetchingTestTransform(realm = realm) else trap("out of memory")
    let transform = fetching_test_transform_stream(vm, realm, captures)
    *transform_root = gc.root_create(transform)
    test_promise_leave(settings)

    return FetchingTestKept(
        request = gc.make_weak[FetchRequest](request),
        callback = gc.make_weak[gc.Function1[FetchResponse*, unit]](pending.m_callback else trap("a callback")),
        response = gc.make_weak[FetchResponse](response),
        fetch_params = gc.make_weak[FetchParams](fetch_params),
        stream = gc.make_weak[StreamsReadableStream](stream),
        transform_readable = gc.make_weak[StreamsReadableStream](streams_transform_stream_readable(transform)),
        transform_controller = gc.make_weak[StreamsTransformStreamDefaultController](streams_transform_stream_controller(transform)),
    )

noinline func run_fetching_test_visit_edges():
    let (vm, realm) = web_test_create_vm_and_settings_realm()
    var pending = gc.root_create[FetchPendingResponse](none)
    var receiver = gc.root_create[FetchFetchedDataReceiver](none)
    var transform = gc.root_create[StreamsTransformStream](none)
    let kept = make_fetching_test_kept(vm, realm, &pending, &receiver, &transform)
    web_test_clobber_stack()
    gc.heap_collect_garbage(vm_heap(vm))
    assert(web_test_alive(&kept.request))
    assert(web_test_alive(&kept.callback))
    assert(web_test_alive(&kept.response))
    assert(web_test_alive(&kept.fetch_params))
    assert(web_test_alive(&kept.stream))
    assert(web_test_alive(&kept.transform_readable))
    assert(web_test_alive(&kept.transform_controller))

    gc.root_release(&pending)
    gc.root_release(&receiver)
    gc.root_release(&transform)
    web_test_clobber_stack()
    gc.heap_collect_garbage(vm_heap(vm))
    assert(not web_test_alive(&kept.callback))
    assert(not web_test_alive(&kept.transform_controller))
    web_test_destroy_vm(vm)

test "what pending responses, fetched data receivers and transform streams keep alive":
    var event_loop = FetchingTestEventLoop()
    fetching_test_begin(&event_loop)
    defer fetching_test_end()
    run_fetching_test_visit_edges()