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)