Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::*;
#[test]
fn webrtc_signaling_surface_stays_explicit_about_the_missing_ice_transport() {
let mut vm = new_storage_test_vm("https://webrtc-surface.test/");
vm.exec(
r#"
(() => {
const descriptor = (owner, name) => {
const value = Object.getOwnPropertyDescriptor(owner, name);
return value && [
value.enumerable,
value.configurable,
value.writable,
typeof value.value,
value.value?.name,
value.value?.length,
typeof value.get,
typeof value.set,
];
};
const throwsTypeError = callback => {
try {
callback();
return false;
} catch (error) {
return error instanceof TypeError;
}
};
const configuration = {
iceCandidatePoolSize: 1,
iceServers: [
{ urls: "stun:stun.cloudflare.com:3478" },
{ urls: "stun:stun.l.google.com:19302" },
{ urls: "stun:stun1.l.google.com:19302" },
],
};
const peer = new RTCPeerConnection(configuration);
const channel = peer.createDataChannel("");
const events = [];
for (const type of ["icegatheringstatechange", "icecandidate"]) {
peer.addEventListener(type, event => events.push([
event.type,
peer.iceGatheringState,
event.candidate === null,
]));
}
const audio = RTCRtpReceiver.getCapabilities("audio");
const video = RTCRtpReceiver.getCapabilities("video");
const offerPromise = peer.createOffer({
offerToReceiveAudio: true,
offerToReceiveVideo: true,
});
globalThis.__webrtcProbe = {
constructor: [
descriptor(window, "RTCPeerConnection"),
RTCPeerConnection.name,
RTCPeerConnection.length,
Object.prototype.toString.call(RTCPeerConnection.prototype),
Object.getPrototypeOf(RTCPeerConnection.prototype) === EventTarget.prototype,
throwsTypeError(() => RTCPeerConnection()),
],
receiver: [
descriptor(window, "RTCRtpReceiver"),
descriptor(RTCRtpReceiver, "getCapabilities"),
throwsTypeError(() => new RTCRtpReceiver()),
audio.codecs.length,
audio.headerExtensions.length,
audio.codecs[0].mimeType,
video.codecs.length,
video.headerExtensions.length,
video.codecs[0].mimeType,
RTCRtpReceiver.getCapabilities("bogus"),
],
methodDescriptors: ["createDataChannel", "createOffer", "setLocalDescription", "close"]
.map(name => [name, descriptor(RTCPeerConnection.prototype, name)]),
initial: [
Object.prototype.toString.call(peer),
peer instanceof RTCPeerConnection,
peer instanceof EventTarget,
peer.signalingState,
peer.iceGatheringState,
peer.iceConnectionState,
peer.connectionState,
peer.localDescription,
peer.currentLocalDescription,
peer.pendingLocalDescription,
Object.prototype.toString.call(channel),
channel instanceof RTCDataChannel,
channel instanceof EventTarget,
channel.label,
channel.ordered,
channel.maxPacketLifeTime,
channel.maxRetransmits,
channel.protocol,
channel.negotiated,
channel.id,
channel.readyState,
channel.bufferedAmount,
channel.binaryType,
],
promiseTag: Object.prototype.toString.call(offerPromise),
settled: false,
};
offerPromise
.then(offer => {
__webrtcProbe.offer = [
Object.prototype.toString.call(offer),
offer.constructor.name,
offer.type,
offer.sdp.includes("m=audio"),
offer.sdp.includes("m=video"),
offer.sdp.includes("m=application"),
];
return peer.setLocalDescription(offer);
})
.then(value => {
__webrtcProbe.setLocalResult = typeof value;
__webrtcProbe.afterSetLocal = [
peer.signalingState,
peer.iceGatheringState,
peer.iceConnectionState,
peer.connectionState,
peer.localDescription?.type,
peer.currentLocalDescription,
peer.pendingLocalDescription?.type,
events,
];
peer.close();
__webrtcProbe.afterClose = [
peer.signalingState,
peer.iceGatheringState,
peer.iceConnectionState,
peer.connectionState,
];
__webrtcProbe.settled = true;
});
})()
"#,
None,
)
.expect("WebRTC signaling probe should execute");
let result = vm
.eval("JSON.stringify(globalThis.__webrtcProbe)")
.expect("WebRTC signaling probe should be readable");
let value: serde_json::Value =
serde_json::from_str(&result).expect("WebRTC signaling probe should return JSON");
assert_eq!(value["constructor"][1], "RTCPeerConnection");
assert_eq!(value["constructor"][2], 0);
assert_eq!(value["constructor"][3], "[object RTCPeerConnection]");
assert_eq!(value["constructor"][4], true);
assert_eq!(value["constructor"][5], true);
assert_eq!(
value["constructor"][0],
serde_json::json!([
false,
true,
true,
"function",
"RTCPeerConnection",
0,
"undefined",
"undefined"
])
);
assert_eq!(value["receiver"][2], true);
assert_eq!(value["receiver"][3], 8);
assert_eq!(value["receiver"][4], 4);
assert_eq!(value["receiver"][5], "audio/opus");
assert_eq!(value["receiver"][6], 19);
assert_eq!(value["receiver"][7], 11);
assert_eq!(value["receiver"][8], "video/VP8");
assert!(value["receiver"][9].is_null());
assert_eq!(
value["initial"],
serde_json::json!([
"[object RTCPeerConnection]",
true,
true,
"stable",
"new",
"new",
"new",
null,
null,
null,
"[object RTCDataChannel]",
true,
true,
"",
true,
null,
null,
"",
false,
null,
"connecting",
0,
"arraybuffer"
])
);
assert_eq!(value["promiseTag"], "[object Promise]");
assert_eq!(
value["offer"],
serde_json::json!(["[object Object]", "Object", "offer", true, true, true])
);
assert_eq!(value["setLocalResult"], "undefined");
assert_eq!(
value["afterSetLocal"],
serde_json::json!([
"have-local-offer",
"new",
"new",
"new",
"offer",
null,
"offer",
[]
])
);
assert_eq!(
value["afterClose"],
serde_json::json!(["closed", "new", "closed", "closed"])
);
assert_eq!(value["settled"], true);
for entry in value["methodDescriptors"]
.as_array()
.expect("WebRTC method descriptors")
{
let name = entry[0].as_str().expect("WebRTC method name");
let descriptor = &entry[1];
assert_eq!(descriptor[0], true, "{name} enumerable");
assert_eq!(descriptor[1], true, "{name} configurable");
assert_eq!(descriptor[2], true, "{name} writable");
assert_eq!(descriptor[3], "function", "{name} value type");
assert_eq!(descriptor[4], name, "{name} function name");
assert_eq!(descriptor[5], usize::from(name == "createDataChannel"));
}
}
#[test]
fn rtc_transport_interfaces_have_realm_local_constructors_and_exposure() {
for url in [
"https://interface-exposure.test/",
"http://interface-exposure.test/",
] {
let mut vm = new_storage_test_vm(url);
assert_eq!(vm.eval(r#"
(() => {
const assert = (ok, message) => { if (!ok) throw Error(message); };
const names = ["RTCCertificate", "RTCDTMFSender", "RTCDtlsTransport", "RTCIceTransport", "RTCRtpSender", "RTCRtpTransceiver", "RTCSctpTransport", "RTCStatsReport"];
const parents = {"RTCCertificate": null, "RTCDTMFSender": "EventTarget", "RTCDtlsTransport": "EventTarget", "RTCIceTransport": "EventTarget", "RTCRtpSender": null, "RTCRtpTransceiver": null, "RTCSctpTransport": "EventTarget", "RTCStatsReport": null};
if (!document.documentElement) document.appendChild(document.createElement('html'));
if (!document.body) document.documentElement.appendChild(document.createElement('body'));
const child = document.createElement('iframe');
document.body.appendChild(child);
const other = child.contentWindow;
for (const realm of [window, other]) {
for (const name of names) {
const C = realm[name];
assert(typeof C === 'function' && C.name === name && C.length === 0, name + ' constructor');
assert(C.prototype.constructor === C, name + ' prototype identity');
assert(Object.getPrototypeOf(C.prototype) === (parents[name] ? realm[parents[name]].prototype : realm.Object.prototype), name + ' prototype inheritance');
assert(realm[name] === C, name + ' stable lazy materialization');
for (const invoke of [() => C(), () => new C(), () => Reflect.construct(C, [], function Subclass() {})]) {
let error;
try { invoke(); } catch (caught) { error = caught; }
assert(error instanceof realm.TypeError, name + ' rejects construction in callee realm');
}
assert(C !== (realm === window ? other[name] : window[name]), name + ' distinct realm constructors');
}
}
return 'passed';
})()
"#).unwrap(), "passed", "{url}");
}
}