mozilla-central/remote/cdp/test/browser/runtime/browser_evaluate.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

/* Any copyright is dedicated to the Public Domain.
"use strict";
const TEST_DOC = toDataURL("default-test-page");
add_task(async function contextIdInvalidValue({ client }) {
const { Runtime } = client;
await enableRuntime(client);
await Assert.rejects(
Runtime.evaluate({ expression: "", contextId: -1 }),
err => err.message.includes("Cannot find context with specified id"),
"Cannot find context with specified id"
);
});
add_task(async function contextIdNotSpecified({ client }) {
const { Runtime } = client;
await loadURL(TEST_DOC);
await enableRuntime(client);
const { result } = await Runtime.evaluate({ expression: "location.href" });
is(result.value, TEST_DOC, "Works against the current document");
});
add_task(async function contextIdSpecified({ client }) {
const { Runtime } = client;
await loadURL(TEST_DOC);
const { id: contextId } = await enableRuntime(client);
const { result } = await Runtime.evaluate({
expression: "location.href",
contextId,
});
is(result.value, TEST_DOC, "Works against the targetted document");
});
add_task(async function returnAsObjectTypes({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const expressions = [
{ expression: "({foo:true})", type: "object", subtype: undefined },
{ expression: "Symbol('foo')", type: "symbol", subtype: undefined },
{ expression: "new Promise(()=>{})", type: "object", subtype: "promise" },
{ expression: "new Int8Array(8)", type: "object", subtype: "typedarray" },
{ expression: "new WeakMap()", type: "object", subtype: "weakmap" },
{ expression: "new WeakSet()", type: "object", subtype: "weakset" },
{ expression: "new Map()", type: "object", subtype: "map" },
{ expression: "new Set()", type: "object", subtype: "set" },
{ expression: "/foo/", type: "object", subtype: "regexp" },
{ expression: "[1, 2]", type: "object", subtype: "array" },
{ expression: "new Proxy({}, {})", type: "object", subtype: "proxy" },
{ expression: "new Date()", type: "object", subtype: "date" },
{
expression: "document",
type: "object",
subtype: "node",
className: "HTMLDocument",
description: "#document",
},
{
expression: `(() => {{
const div = document.createElement('div');
div.id = "foo";
return div;
}})()`,
type: "object",
subtype: "node",
className: "HTMLDivElement",
description: "div#foo",
},
];
for (const entry of expressions) {
const { expression, type, subtype, className, description } = entry;
const { result } = await Runtime.evaluate({ expression });
is(result.type, type, "The type is correct");
is(result.subtype, subtype, "The subtype is correct");
ok(!!result.objectId, "Got an object id");
if (className) {
is(result.className, className, "The className is correct");
}
if (description) {
is(result.description, description, "The description is correct");
}
}
});
add_task(async function returnAsObjectDifferentObjectIds({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const expressions = [{}, "document"];
for (const expression of expressions) {
const { result: result1 } = await Runtime.evaluate({
expression: JSON.stringify(expression),
});
const { result: result2 } = await Runtime.evaluate({
expression: JSON.stringify(expression),
});
is(
result1.objectId,
result2.objectId,
`Different object ids returned for ${expression}`
);
}
});
add_task(async function returnAsObjectPrimitiveTypes({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const expressions = [42, "42", true, 4.2];
for (const expression of expressions) {
const { result } = await Runtime.evaluate({
expression: JSON.stringify(expression),
});
is(result.value, expression, `Evaluating primitive '${expression}' works`);
is(result.type, typeof expression, `${expression} type is correct`);
}
});
add_task(async function returnAsObjectNotSerializable({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const notSerializableNumbers = {
number: ["-0", "NaN", "Infinity", "-Infinity"],
bigint: ["42n"],
};
for (const type in notSerializableNumbers) {
for (const expression of notSerializableNumbers[type]) {
const { result } = await Runtime.evaluate({ expression });
Assert.deepEqual(
result,
{
type,
unserializableValue: expression,
description: expression,
},
`Evaluating unserializable '${expression}' works`
);
}
}
});
// `null` is special as it has its own subtype, is of type 'object'
// but is returned as a value, without an `objectId` attribute
add_task(async function returnAsObjectNull({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const { result } = await Runtime.evaluate({
expression: "null",
});
Assert.deepEqual(
result,
{
type: "object",
subtype: "null",
value: null,
},
"Null type is correct"
);
});
// undefined doesn't work with JSON.stringify, so test it independently
add_task(async function returnAsObjectUndefined({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const { result } = await Runtime.evaluate({
expression: "undefined",
});
Assert.deepEqual(
result,
{
type: "undefined",
},
"Undefined type is correct"
);
});
add_task(async function exceptionDetailsJavascriptError({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const { exceptionDetails } = await Runtime.evaluate({
expression: "doesNotExists()",
});
Assert.deepEqual(
exceptionDetails,
{
text: "doesNotExists is not defined",
},
"Javascript error is passed to the client"
);
});
add_task(async function exceptionDetailsThrowError({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const { exceptionDetails } = await Runtime.evaluate({
expression: "throw new Error('foo')",
});
Assert.deepEqual(
exceptionDetails,
{
text: "foo",
},
"Exception details are passed to the client"
);
});
add_task(async function exceptionDetailsThrowValue({ client }) {
const { Runtime } = client;
await enableRuntime(client);
const { exceptionDetails } = await Runtime.evaluate({
expression: "throw 'foo'",
});
Assert.deepEqual(
exceptionDetails,
{
exception: {
type: "string",
value: "foo",
},
},
"Exception details are passed as a RemoteObject"
);
});