Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / fetch / infrastructure / tests_fetch_infrastructure_1.lucb

#==============================================================================================
#
#   tests_fetch_infrastructure_1 - Fetch/Infrastructure, ReferrerPolicy and SecureContexts:
#   the donor's TestFetchURL and the oracle's cases
#
#   DESCRIPTION:
#       Port of Tests/LibWeb/TestFetchURL.cpp (lines 13-114: data: URLs), and the runner of
#       tests_fetch_infrastructure_cases: each case's operation is run and its result printed
#       the way the local oracle prints the reference build's
#       (oracles/luce-browser-engine/fetch_http, cases_p2a.txt). The case struct and the
#       printing helpers are p2b's (tests_fetch_http_1).
#
#==============================================================================================

# mark: TestFetchURL.cpp ========================================================================

## A parsed test URL: `URL::Parser::basic_parse(text)`, with EXPECT(url.has_value()).
func fetch_test_data_url_parse(text: str) -> web_url.Url:
    return web_url.parser_basic_parse(ak.sv(text)) else trap("EXPECT(url.has_value())")

## The checks every TestFetchURL case makes of a data: URL: its scheme is "data" and it has no host.
func fetch_test_data_url_is_data(url: const web_url.Url*):
    let scheme = web_url.url_scheme(url)
    assert(ak.string_eq_string_view(&scheme, ak.sv("data")))
    assert(web_url.url_host(url) == none)

## `url->serialize() == expected`.
func fetch_test_data_url_serializes_as(url: const web_url.Url*, expected: str) -> bool:
    let serialized = web_url.url_serialize(url)
    return ak.string_eq_string_view(&serialized, ak.sv(expected))

## `TRY_OR_FAIL(process_data_url(url))`, with the checks of its MIME type's serialization and its body.
func fetch_test_data_url_processes_to(url: web_url.Url, mime_type: str, body: str):
    let data_url = fetch_process_data_url(url) else trap("TRY_OR_FAIL(process_data_url(url))")
    let serialized = mime_type_serialized(&data_url.mime_type)
    assert(ak.string_eq_string_view(&serialized, ak.sv(mime_type)))
    let bytes = ak.string_view_from_bytes(ak.byte_buffer_bytes_const(&data_url.body))
    assert(ak.string_view_equals(&bytes, body))

## Ported from TestFetchURL.cpp:13 data_url.
test "Fetch: data URL":
    let url = fetch_test_data_url_parse("data:text/html,test")
    fetch_test_data_url_is_data(&url)
    assert(fetch_test_data_url_serializes_as(&url, "data:text/html,test"))
    fetch_test_data_url_processes_to(url, "text/html", "test")

## Ported from TestFetchURL.cpp:26 data_url_default_mime_type.
test "Fetch: data URL default MIME type":
    let url = fetch_test_data_url_parse("data:,test")
    fetch_test_data_url_is_data(&url)
    assert(fetch_test_data_url_serializes_as(&url, "data:,test"))
    fetch_test_data_url_processes_to(url, "text/plain;charset=US-ASCII", "test")

## Ported from TestFetchURL.cpp:39 data_url_encoded.
test "Fetch: data URL encoded":
    let url = fetch_test_data_url_parse("data:text/html,Hello%20friends%2C%0X%X0")
    fetch_test_data_url_is_data(&url)
    assert(fetch_test_data_url_serializes_as(&url, "data:text/html,Hello%20friends%2C%0X%X0"))
    fetch_test_data_url_processes_to(url, "text/html", "Hello friends,%0X%X0")

## Ported from TestFetchURL.cpp:52 data_url_base64_encoded.
test "Fetch: data URL base64 encoded":
    let url = fetch_test_data_url_parse("data:text/html;base64,dGVzdA==")
    fetch_test_data_url_is_data(&url)
    assert(fetch_test_data_url_serializes_as(&url, "data:text/html;base64,dGVzdA=="))
    fetch_test_data_url_processes_to(url, "text/html", "test")

## Ported from TestFetchURL.cpp:65 data_url_base64_encoded_default_mime_type.
test "Fetch: data URL base64 encoded default MIME type":
    let url = fetch_test_data_url_parse("data:;base64,dGVzdA==")
    fetch_test_data_url_is_data(&url)
    assert(fetch_test_data_url_serializes_as(&url, "data:;base64,dGVzdA=="))
    fetch_test_data_url_processes_to(url, "text/plain;charset=US-ASCII", "test")

## Ported from TestFetchURL.cpp:78 data_url_base64_encoded_with_whitespace.
test "Fetch: data URL base64 encoded with whitespace":
    let url = fetch_test_data_url_parse("data: text/html ;     bAsE64 , dGVz dA== ")
    fetch_test_data_url_is_data(&url)
    assert(fetch_test_data_url_serializes_as(&url, "data: text/html ;     bAsE64 , dGVz dA=="))
    fetch_test_data_url_processes_to(url, "text/html", "test")

## Ported from TestFetchURL.cpp:91 data_url_base64_encoded_with_inline_whitespace.
test "Fetch: data URL base64 encoded with inline whitespace":
    let url = fetch_test_data_url_parse("data:text/javascript;base64,%20ZD%20Qg%0D%0APS%20An%20Zm91cic%0D%0A%207%20")
    fetch_test_data_url_is_data(&url)
    fetch_test_data_url_processes_to(url, "text/javascript", "d4 = 'four';")

## Ported from TestFetchURL.cpp:103 data_url_completed_with_fragment.
test "Fetch: data URL completed with fragment":
    let base = fetch_test_data_url_parse("data:text/plain,test")
    let url = web_url.url_complete_url(&base, ak.sv("#a")) else trap("EXPECT(url.has_value())")
    fetch_test_data_url_is_data(&url)
    let fragment = web_url.url_fragment(&url) else trap("the URL has a fragment")
    assert(ak.string_eq_string_view(&fragment, ak.sv("a")))
    fetch_test_data_url_processes_to(url, "text/plain", "test")

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

## The oracle's `opt_url`: a URL serialized, or "null".
func fetch_infrastructure_test_optional_url(builder: ak.StringBuilder*, url: web_url.Url?):
    if let present = url:
        let serialized = web_url.url_serialize(&present)
        fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&serialized))
    else:
        ak.string_builder_append(builder, "null")

## The oracle's `blocking`.
func fetch_infrastructure_test_blocking(builder: ak.StringBuilder*, blocking: FetchRequestOrResponseBlocking):
    ak.string_builder_append(builder, "blocked" if blocking == FetchRequestOrResponseBlocking.blocked else "allowed")

## The oracle's `trust`.
func fetch_infrastructure_test_trust(builder: ak.StringBuilder*, trustworthiness: SecureContextsTrustworthiness):
    ak.string_builder_append(builder, "trustworthy" if trustworthiness == SecureContextsTrustworthiness.potentially_trustworthy else "not-trustworthy")

## The oracle's `f64_bits`: a double as the decimal value of its bits (compared exactly: the timings add, divide,
## floor and multiply, which are correctly rounded on every platform).
func fetch_infrastructure_test_f64(builder: ak.StringBuilder*, value: f64):
    ak.format_u64(builder, value.bits())

## The oracle's `destination_of`: "-" is no destination, anything else a potential destination translated.
func fetch_infrastructure_test_destination(argument: ak.StringView) -> FetchRequestDestination?:
    if ak.string_view_equals(&argument, "-"):
        return none
    return fetch_translate_potential_destination(argument)

## The oracle's `policy_of`.
func fetch_infrastructure_test_policy(argument: ak.StringView) -> ReferrerPolicyReferrerPolicy:
    return referrer_policy_from_string(argument) else trap("the test policy parses")

## The oracle's `response_with_headers`: a response with the headers of the name/value arguments from `first` on.
func fetch_infrastructure_test_response_with_headers(vm: Vm*, a: const ak.StringView[], first: usize) -> FetchResponse*:
    let response = fetch_infrastructure_response_create(vm)
    var i = first
    while i + 1 < a.length:
        http_header_list_append(fetch_response_header_list(response), fetch_http_test_header(a[i], a[i + 1]))
        i += 2
    return response

## A response with a `Referrer-Policy` header of each argument from `first` on.
func fetch_infrastructure_test_response_with_referrer_policies(vm: Vm*, a: const ak.StringView[], first: usize) -> FetchResponse*:
    let response = fetch_infrastructure_response_create(vm)
    for value in a[first..]:
        http_header_list_append(fetch_response_header_list(response), http_header_create(ak.sv("Referrer-Policy"), value))
    return response

## The oracle's `describe_timing`.
func fetch_infrastructure_test_describe_timing(builder: ak.StringBuilder*, timing: FetchTimingInfo*):
    let values: f64[9] = [
        fetch_timing_info_start_time(timing),
        fetch_timing_info_redirect_start_time(timing),
        fetch_timing_info_redirect_end_time(timing),
        fetch_timing_info_post_redirect_start_time(timing),
        fetch_timing_info_final_service_worker_start_time(timing),
        fetch_timing_info_final_network_request_start_time(timing),
        fetch_timing_info_first_interim_network_response_start_time(timing),
        fetch_timing_info_final_network_response_start_time(timing),
        fetch_timing_info_end_time(timing),
    ]
    for (index, value) in values.indexed():
        if index != 0:
            ak.string_builder_append(builder, " ; ")
        fetch_infrastructure_test_f64(builder, value)
    ak.string_builder_append(builder, " ; ")
    if let connection = fetch_timing_info_final_connection_timing_info(timing):
        let times: f64[5] = [connection.domain_lookup_start_time, connection.domain_lookup_end_time, connection.connection_start_time, connection.connection_end_time, connection.secure_connection_start_time]
        for time in times:
            fetch_infrastructure_test_f64(builder, time)
            ak.string_builder_append(builder, ",")
        ak.string_builder_append_string_view(builder, ak.fly_string_bytes_as_string_view(&connection.alpn_negotiated_protocol))
    else:
        ak.string_builder_append(builder, "null")
    ak.string_builder_append(builder, " ; ")
    ak.format_u64(builder, (u64)ak.vector_size(fetch_timing_info_server_timing_headers_const(timing)))
    ak.string_builder_append(builder, " ; ")
    fetch_http_test_bool(builder, fetch_timing_info_render_blocking(timing))

## The oracle's `state_name`.
func fetch_infrastructure_test_state_name(state: FetchControllerState) -> str:
    match state:
        .ongoing: return "ongoing"
        .terminated: return "terminated"
        .aborted: return "aborted"
        .stopped: return "stopped"
        _: return "?"

## The oracle's `controller` op: steps on a new fetch params' controller.
func fetch_infrastructure_test_controller(builder: ak.StringBuilder*, vm: Vm*, a: const ak.StringView[]):
    let request = fetch_request_create(vm)
    let params = fetch_params_create(vm, request, fetch_timing_info_create(vm))
    let controller = fetch_params_controller(params)
    var i: usize = 0
    while i < a.length:
        let step = a[i]
        i += 1
        if i > 1:
            ak.string_builder_append(builder, " ; ")
        ak.string_builder_append_string_view(builder, step)
        if ak.string_view_equals(&step, "id"):
            ak.string_builder_append(builder, "=")
            ak.format_u64(builder, fetch_controller_next_fetch_task_id(controller))
        elif ak.string_view_equals(&step, "queued"):
            fetch_controller_fetch_task_queued(controller, fetch_http_test_u64(a[i]), fetch_http_test_u64(a[i + 1]))
            i += 2
        elif ak.string_view_equals(&step, "complete"):
            fetch_controller_fetch_task_complete(controller, fetch_http_test_u64(a[i]))
            i += 1
        elif ak.string_view_equals(&step, "terminate"):
            fetch_controller_terminate(controller)
        elif ak.string_view_equals(&step, "copy"):
            let copy = fetch_params_copy(params)
            ak.string_builder_append(builder, "=")
            fetch_http_test_bool(builder, fetch_params_controller(copy) == controller)
            ak.string_builder_append(builder, ",")
            fetch_http_test_bool(builder, fetch_params_request(copy) == request)
            ak.string_builder_append(builder, ",")
            fetch_http_test_bool(builder, fetch_params_algorithms(copy) == fetch_params_algorithms(params))
            ak.string_builder_append(builder, ",")
            fetch_http_test_bool(builder, fetch_params_timing_info(copy) == fetch_params_timing_info(params))
        ak.string_builder_append(builder, ":")
        ak.string_builder_append(builder, fetch_infrastructure_test_state_name(fetch_controller_state(controller)))
        ak.string_builder_append(builder, ",")
        ak.format_u64(builder, (u64)ak.hash_map_size(&controller.m_ongoing_fetch_tasks))
        ak.string_builder_append(builder, ",")
        fetch_http_test_bool(builder, fetch_params_is_aborted(params))
        ak.string_builder_append(builder, ",")
        fetch_http_test_bool(builder, fetch_params_is_canceled(params))

## The oracle's `timing` op.
func fetch_infrastructure_test_timing(builder: ak.StringBuilder*, vm: Vm*, a: const ak.StringView[]):
    let timing = fetch_timing_info_create(vm)
    fetch_timing_info_set_start_time(timing, ak.string_view_to_number_f64(&a[0]) else trap("not a number"))
    fetch_infrastructure_test_describe_timing(builder, timing)
    let opaque = fetch_create_opaque_timing_info(vm, timing)
    ak.string_builder_append(builder, " | ")
    fetch_infrastructure_test_describe_timing(builder, opaque)
    var final_timings = RequestsRequestTimingInfo()
    let microseconds = memory.frame[i64](8, 8)
    for index in 0..<8:
        let argument = a[2 + index]
        microseconds[index] = ak.string_view_to_number_i64(&argument) else trap("not a number")
    final_timings.domain_lookup_start_microseconds = microseconds[0]
    final_timings.domain_lookup_end_microseconds = microseconds[1]
    final_timings.connect_start_microseconds = microseconds[2]
    final_timings.connect_end_microseconds = microseconds[3]
    final_timings.secure_connect_start_microseconds = microseconds[4]
    final_timings.request_start_microseconds = microseconds[5]
    final_timings.response_start_microseconds = microseconds[6]
    final_timings.response_end_microseconds = microseconds[7]
    final_timings.http_version_alpn_identifier = RequestsAlpnHttpVersion(ak.string_view_to_number_i32(&a[10]) else trap("not a number"))
    let cross_origin_isolated_capability = HtmlCanUseCrossOriginIsolatedApIs.yes if ak.string_view_equals(&a[1], "yes") else HtmlCanUseCrossOriginIsolatedApIs.no
    fetch_timing_info_update_final_timings(timing, &final_timings, cross_origin_isolated_capability)
    ak.string_builder_append(builder, " | ")
    fetch_infrastructure_test_describe_timing(builder, timing)

## The oracle's `run_p2a`: the result line of one case.
func fetch_infrastructure_test_run(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 == "data_url" or op == "data_url_complete":
        var url = web_url.parser_basic_parse(a[0]) else trap("the test URL parses")
        if op == "data_url_complete":
            url = web_url.url_complete_url(&url, a[1]) else trap("the completed URL parses")
        let serialized = web_url.url_serialize(&url)
        fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&serialized))
        ak.string_builder_append(builder, " ; ")
        let data_url = fetch_process_data_url(url) catch:
            ak.string_builder_append(builder, "failure")
            return
        let mime_serialized = mime_type_serialized(&data_url.mime_type)
        fetch_http_test_escape(builder, ak.string_bytes_as_string_view(&mime_serialized))
        ak.string_builder_append(builder, " ; ")
        fetch_http_test_escape(builder, ak.string_view_from_bytes(ak.byte_buffer_bytes_const(&data_url.body)))
    elif op == "bad_ports":
        var first = true
        for port: u32 in 0..=65535:
            if fetch_is_bad_port((u16)port):
                if not first:
                    ak.string_builder_append(builder, " ")
                first = false
                ak.format_u64(builder, port)
    elif op == "block_bad_port":
        let request = fetch_request_create(vm)
        fetch_request_set_url(request, fetch_http_test_url(a[0]))
        fetch_infrastructure_test_blocking(builder, fetch_block_bad_port(request))
    elif op == "nosniff":
        let response = fetch_infrastructure_test_response_with_headers(vm, a, 0)
        fetch_http_test_bool(builder, fetch_determine_nosniff(fetch_response_header_list(response)))
    elif op == "nosniff_block" or op == "mime_block":
        let request = fetch_request_create(vm)
        fetch_request_set_destination(request, fetch_infrastructure_test_destination(a[0]))
        let response = fetch_infrastructure_test_response_with_headers(vm, a, 1)
        if op == "nosniff_block":
            fetch_infrastructure_test_blocking(builder, fetch_should_response_to_request_be_blocked_due_to_nosniff(response, request))
        else:
            fetch_infrastructure_test_blocking(builder, fetch_should_response_to_request_be_blocked_due_to_its_mime_type(response, request))
    elif op == "referrer_policy_header":
        let response = fetch_infrastructure_test_response_with_referrer_policies(vm, a, 0)
        ak.string_builder_append_string_view(builder, referrer_policy_to_string(referrer_policy_parse_a_referrer_policy_from_a_referrer_policy_header(response)))
    elif op == "referrer_policy_on_redirect":
        let request = fetch_request_create(vm)
        fetch_request_set_referrer_policy(request, fetch_infrastructure_test_policy(a[0]))
        let response = fetch_infrastructure_test_response_with_referrer_policies(vm, a, 1)
        referrer_policy_set_request_referrer_policy_on_redirect(request, response)
        ak.string_builder_append_string_view(builder, referrer_policy_to_string(fetch_request_referrer_policy(request)))
    elif op == "referrer_policy_strings":
        for policy: i32 in 0..=(i32)ReferrerPolicyReferrerPolicy.unsafe_url:
            if policy != 0:
                ak.string_builder_append(builder, " ; ")
            ak.string_builder_append_string_view(builder, referrer_policy_to_string(ReferrerPolicyReferrerPolicy(policy)))
    elif op == "referrer_policy_from_string":
        if let policy = referrer_policy_from_string(a[0]):
            ak.string_builder_append(builder, "\"")
            ak.string_builder_append_string_view(builder, referrer_policy_to_string(policy))
            ak.string_builder_append(builder, "\"")
        else:
            ak.string_builder_append(builder, "null")
    elif op == "strip":
        var url: web_url.Url? = none
        if not ak.string_view_equals(&a[0], "null"):
            url = fetch_http_test_url(a[0])
        let origin_only = ReferrerPolicyOriginOnly.yes if ak.string_view_equals(&a[1], "origin") else ReferrerPolicyOriginOnly.no
        fetch_infrastructure_test_optional_url(builder, referrer_policy_strip_url_for_use_as_referrer(url, origin_only))
    elif op == "determine_referrer":
        let request = fetch_request_create(vm)
        fetch_request_set_referrer_policy(request, fetch_infrastructure_test_policy(a[0]))
        fetch_request_set_referrer(request, .url(fetch_http_test_url(a[1])))
        fetch_request_set_url_list(request, fetch_http_test_url_list(a, 2))
        fetch_infrastructure_test_optional_url(builder, referrer_policy_determine_requests_referrer(request))
    elif op == "trustworthy":
        let url = fetch_http_test_url(a[0])
        fetch_infrastructure_test_trust(builder, secure_contexts_is_origin_potentially_trustworthy(web_url.url_origin(&url)))
        ak.string_builder_append(builder, " ; ")
        fetch_infrastructure_test_trust(builder, secure_contexts_is_url_potentially_trustworthy(url))
    elif op == "opaque_origin_trustworthy":
        let type_ = web_url.OriginOpaqueDataType.file if ak.string_view_equals(&a[0], "file") else web_url.OriginOpaqueDataType.standard
        fetch_infrastructure_test_trust(builder, secure_contexts_is_origin_potentially_trustworthy(web_url.origin_create_opaque(type_)))
    elif op == "timing":
        fetch_infrastructure_test_timing(builder, vm, a)
    elif op == "controller":
        fetch_infrastructure_test_controller(builder, vm, a)
    else:
        trap("unknown op")

test "Fetch/Infrastructure, ReferrerPolicy and SecureContexts give the reference build's results":
    let vm = web_test_create_vm()
    defer web_test_destroy_vm(vm)
    # (The cases allocate more than a test's fixed buffer holds: they allocate in the VM's heap, as the engine does.)
    let allocator: memory.Allocator = vm_heap(vm)
    var failures = 0
    with allocator:
        for test_case in &fetch_infrastructure_cases:
            var builder = ak.string_builder_new()
            fetch_infrastructure_test_run(&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)