// This file exposes the `formSubmissionTemplate` function, which can be used
// to create tests for the form submission encoding of various enctypes:
//
// const urlencodedTest = formSubmissionTemplate(
// "application/x-www-form-urlencoded",
// (expected, _actualFormBody) => expected
// );
//
// urlencodedTest({
// name: "a",
// value: "b",
// expected: "a=b",
// formEncoding: "UTF-8", // optional
// description: "Simple urlencoded test"
// });
//
// The above call to `urlencodedTest` tests the urlencoded form submission for a
// form whose entry list contains a single entry with name "a" and value "b",
// and it checks that the form payload matches the `expected` property after
// isomorphic-encoding.
//
// Since per the spec no normalization of the form entries should happen before
// the actual form encoding, each call to `urlencodedTest` will in fact add two
// tests: one submitting the entry as a form control (marked "normal form"), and
// one adding the entry through the `formdata` event (marked "formdata event").
// Both cases are compared against the same expected value.
//
// Since multipart/form-data boundary strings can't be predicted ahead of time,
// the second parameter of `formSubmissionTemplate` allows transforming the
// expected value passed to each test. The second argument of that callback
// is the actual form body (isomorphic-decoded). When this callback is used, the
// `expected` property doesn't need to be a string.
(() => {
// Using echo-content-escaped.py rather than
// /fetch/api/resources/echo-content.py to work around WebKit not
// percent-encoding \x00, which causes the response to be detected as
// a binary file and served as a download.
const ACTION_URL = "/FileAPI/file/resources/echo-content-escaped.py";
const IFRAME_NAME = "formtargetframe";
// Undoes the escapes from echo-content-escaped.py
function unescape(str) {
return str
.replace(/\r\n?|\n/g, "\r\n")
.replace(
/\\x[0-9A-Fa-f]{2}/g,
(escape) => String.fromCodePoint(parseInt(escape.substring(2), 16)),
)
.replace(/\\\\/g, "\\");
}
// Tests the form submission of an entry list containing a single entry.
//
// `expectedBuilder` is a function that takes in the actual form body
// (necessary to get the multipart/form-data payload) and returns the form
// body that should be expected.
//
// If `testFormData` is false, the form entry will be submitted in for
// controls. If it is true, it will submitted by modifying the entry list
// during the `formdata` event.
async function formSubmissionTest({
name,
value,
expectedBuilder,
enctype,
formEncoding,
testFormData = false,
testCase,
}) {
if (document.readyState !== "complete") {
await new Promise((resolve) => addEventListener("load", resolve));
}
const formTargetFrame = Object.assign(document.createElement("iframe"), {
name: IFRAME_NAME,
});
document.body.append(formTargetFrame);
testCase.add_cleanup(() => {
document.body.removeChild(formTargetFrame);
});
const form = Object.assign(document.createElement("form"), {
acceptCharset: formEncoding,
action: ACTION_URL,
method: "POST",
enctype,
target: IFRAME_NAME,
});
document.body.append(form);
testCase.add_cleanup(() => {
document.body.removeChild(form);
});
if (!testFormData) {
const input = document.createElement("input");
input.name = name;
if (value instanceof File) {
input.type = "file";
const dataTransfer = new DataTransfer();
dataTransfer.items.add(value);
input.files = dataTransfer.files;
} else {
input.type = "hidden";
input.value = value;
}
form.append(input);
} else {
form.addEventListener("formdata", (evt) => {
evt.formData.append(name, value);
});
}
await new Promise((resolve) => {
form.submit();
formTargetFrame.onload = resolve;
});
const serialized = unescape(
formTargetFrame.contentDocument.body.textContent,
);
const expected = expectedBuilder(serialized);
assert_equals(serialized, expected);
}
// This function returns a function to add individual form tests corresponding
// to some enctype.
// `expectedBuilder` is an optional callback that takes two parameters:
// `expected` (the `expected` property passed to a test) and `actualFormBody`
// (the actual form body submitted by the browser, isomorphic-decoded). It
// must return the correct form body that should have been submitted,
// isomorphic-encoded. This is necessary in order to account for the
// multipart/form-data boundary.
//
// The returned function takes an object with the following properties:
// - `name`, the form entry's name. Must be a string.
// - `value`, the form entry's value, either a string or a `File` object.
// - `expected`, the expected form body. Usually a string, but it can be
// anything depending on `expectedBuilder`.
// - `formEncoding` (optional), the character encoding used for submitting the
// form.
// - `description`, used as part of the testharness test's description.
window.formSubmissionTemplate = (
enctype,
expectedBuilder = (expected) => expected
) => {
function form({
name,
value,
expected,
formEncoding = "utf-8",
description,
}) {
const commonParams = {
name,
value,
expectedBuilder: expectedBuilder.bind(null, expected),
enctype,
formEncoding,
};
// Normal form
promise_test(
(testCase) =>
formSubmissionTest({
...commonParams,
testCase,
}),
`${enctype}: ${description} (normal form)`,
);
// formdata event
promise_test(
(testCase) =>
formSubmissionTest({
...commonParams,
testFormData: true,
testCase,
}),
`${enctype}: ${description} (formdata event)`,
);
}
return form;
};
})();
Codebase Browser
chromium