Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

10.2 KB
Raw Blame
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}");
    }
}