Skip to content

armgit / moli

Public Imported from GitHub
0

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

9.2 KB
Raw Blame
use super::*;

#[test]
fn compression_streams_have_branded_endpoints_and_validate_formats() {
    let mut vm = stream_test_vm();
    let result = vm.eval(r#"
JSON.stringify([CompressionStream, DecompressionStream].map(C => {
  const stream = new C('gzip');
  const other = new (C === CompressionStream ? DecompressionStream : CompressionStream)('gzip');
  const throws = fn => { try { fn(); return false; } catch (e) { return e instanceof TypeError; } };
  return {
    length: C.length,
    own: Object.getOwnPropertyNames(stream),
    endpoints: stream.readable instanceof ReadableStream && stream.writable instanceof WritableStream,
    same: stream.readable === stream.readable && stream.writable === stream.writable,
    newRequired: throws(() => C('gzip')),
    notTransform: throws(() => Object.getOwnPropertyDescriptor(TransformStream.prototype, 'readable').get.call(stream)),
    formats: [undefined, '', 'GZIP', 'gzip ', 'zip', 'br', 'BROTLI', 'brotli ', Symbol()].every(f => throws(() => new C(f))),
    receiver: ['readable','writable'].every(key => {
      const get = Object.getOwnPropertyDescriptor(C.prototype, key).get;
      return [C.prototype, {}, Object.create(C.prototype), other, new TransformStream()]
        .every(receiver => throws(() => get.call(receiver)));
    })
  };
}))
"#).unwrap();
    let expected = serde_json::json!({
        "length": 1, "own": [], "endpoints": true, "same": true,
        "newRequired": true, "notTransform": true, "formats": true, "receiver": true
    });
    assert_eq!(
        serde_json::from_str::<serde_json::Value>(&result).unwrap(),
        serde_json::json!([expected, expected])
    );
}

#[tokio::test(flavor = "current_thread")]
async fn compression_streams_roundtrip_through_response_and_multiple_buffer_sources() {
    let loader = static_http_loader(std::iter::empty::<String>());
    let mut vm =
        new_storage_page_task_executor_test_vm_with_loader("https://stream-runtime.test/", &loader);
    vm.eval(r#"
globalThis.compressionResult = 'pending';
(async () => {
  const result = [];
  for (const format of ['deflate-raw','deflate','gzip','brotli']) {
    const source = new ReadableStream({start(c) {
      c.enqueue(new Uint8Array([65,66]).buffer);
      c.enqueue(new DataView(new Uint8Array([0,67,68,0]).buffer, 1, 2));
      c.enqueue(new Uint8Array([0,69,70,0]).subarray(1,3));
      c.enqueue(new Uint8Array(0));
      c.close();
    }});
    const compressed = await new Response(source.pipeThrough(new CompressionStream(format))).arrayBuffer();
    const bytes = new Uint8Array(compressed);
    const split = new ReadableStream({start(c) {
      for (const byte of bytes) c.enqueue(new Uint8Array([byte]));
      c.close();
    }});
    const text = await new Response(split.pipeThrough(new DecompressionStream(format))).text();
    const empty = new ReadableStream({start(c) { c.close(); }});
    const emptyResult = await new Response(empty.pipeThrough(new CompressionStream(format))
      .pipeThrough(new DecompressionStream(format))).text();
    result.push([text, emptyResult, bytes.length > 0]);
  }
  return result;
})().then(result => compressionResult = result, e => compressionResult = [e.name, e.message]);
"#).unwrap();
    advance_page_task_executor_until_eval_equals(
        &mut vm,
        &loader,
        "String(compressionResult !== 'pending')",
        "true",
        "compression_streams_roundtrip_through_response_and_multiple_buffer_sources",
    )
    .await;
    assert_eq!(
        vm.eval("JSON.stringify(compressionResult)").unwrap(),
        r#"[["ABCDEF","",true],["ABCDEF","",true],["ABCDEF","",true],["ABCDEF","",true]]"#
    );
}

#[tokio::test(flavor = "current_thread")]
async fn compression_streams_reject_invalid_chunks_and_corrupt_or_truncated_data() {
    let loader = static_http_loader(std::iter::empty::<String>());
    let mut vm =
        new_storage_page_task_executor_test_vm_with_loader("https://stream-runtime.test/", &loader);
    vm.eval(r#"
globalThis.compressionErrors = 'pending';
(async () => {
  const rejects = promise => promise.then(() => 'resolved', e => e.name);
  const results = [];
  for (const C of [CompressionStream, DecompressionStream]) {
    for (const chunk of ['bytes', {}, 1, null]) {
      const s = new C('gzip');
      const writer = s.writable.getWriter();
      const reader = s.readable.getReader();
      results.push(await Promise.all([rejects(reader.read()), rejects(writer.write(chunk))]));
    }
  }
  for (const format of ['deflate-raw','deflate','gzip','brotli']) {
    const source = new ReadableStream({start(c) { c.enqueue(new Uint8Array([65])); c.close(); }});
    const bytes = new Uint8Array(await new Response(source.pipeThrough(new CompressionStream(format))).arrayBuffer());
    for (const bad of [bytes.slice(0,-1), new Uint8Array([...bytes,0]), new Uint8Array([255,255])]) {
      const source = new ReadableStream({start(c) { c.enqueue(bad); c.close(); }});
      results.push(await rejects(new Response(source.pipeThrough(new DecompressionStream(format))).arrayBuffer()));
    }
  }
  return results;
})().then(result => compressionErrors = result, e => compressionErrors = [e.name,e.message]);
"#).unwrap();
    advance_page_task_executor_until_eval_equals(
        &mut vm,
        &loader,
        "String(compressionErrors !== 'pending')",
        "true",
        "compression_streams_reject_invalid_chunks_and_corrupt_or_truncated_data",
    )
    .await;
    let result = vm.eval("JSON.stringify(compressionErrors)").unwrap();
    let result: serde_json::Value = serde_json::from_str(&result).unwrap();
    let result = result.as_array().unwrap();
    assert_eq!(result.len(), 20);
    for value in &result[..8] {
        assert_eq!(*value, serde_json::json!(["TypeError", "TypeError"]));
    }
    for value in &result[8..] {
        assert_eq!(*value, "TypeError");
    }
}

#[test]
fn compression_streams_preserve_backpressure_and_cancel_or_abort_reasons() {
    let mut vm = stream_test_vm();
    vm.eval(
        r#"
globalThis.compressionEvents = [];
globalThis.compressor = new CompressionStream('gzip');
globalThis.compressionWriter = compressor.writable.getWriter();
compressionWriter.write(new Uint8Array([65])).then(() => compressionEvents.push('write'));
"#,
    )
    .unwrap();
    assert_eq!(vm.eval("JSON.stringify(compressionEvents)").unwrap(), "[]");
    vm.eval(r#"
compressor.readable.getReader().read().then(({value,done}) => compressionEvents.push(`${value instanceof Uint8Array}:${done}`));
"#).unwrap();
    assert_eq!(
        vm.eval("JSON.stringify(compressionEvents.sort())").unwrap(),
        r#"["true:false","write"]"#
    );
    vm.eval(
        r#"
globalThis.compressionCancellation = 'pending';
(async () => {
  const reason = {};
  const result = [];
  for (const format of ['deflate-raw','deflate','gzip','brotli']) {
    for (const C of [CompressionStream, DecompressionStream]) {
      const s = new C(format);
      const writer = s.writable.getWriter();
      const closed = writer.closed.catch(e => e === reason);
      const write = writer.write(new Uint8Array([1])).catch(e => e === reason);
      await s.readable.cancel(reason);
      result.push(await closed, await write);
      const aborted = new C(format);
      const reader = aborted.readable.getReader();
      const read = reader.read().catch(e => e === reason);
      await aborted.writable.abort(reason);
      result.push(await read);
    }
  }
  return result;
})().then(result => compressionCancellation = result, e => compressionCancellation = e.message);
"#,
    )
    .unwrap();
    let result = vm.eval("JSON.stringify(compressionCancellation)").unwrap();
    assert_eq!(
        serde_json::from_str::<Vec<bool>>(&result).unwrap(),
        vec![true; 24]
    );
}

#[tokio::test(flavor = "current_thread")]
async fn brotli_compression_preserves_backpressure_and_flushes_on_close() {
    let loader = static_http_loader(std::iter::empty::<String>());
    let mut vm =
        new_storage_page_task_executor_test_vm_with_loader("https://stream-runtime.test/", &loader);
    vm.eval(
        r#"
globalThis.brotliEvents = [];
globalThis.brotliStream = new CompressionStream('brotli');
globalThis.brotliWriter = brotliStream.writable.getWriter();
brotliWriter.write(new Uint8Array([65,66])).then(() => brotliEvents.push('write'));
"#,
    )
    .unwrap();
    assert_eq!(vm.eval("JSON.stringify(brotliEvents)").unwrap(), "[]");
    vm.eval(
        r#"
globalThis.brotliBytes = new Response(brotliStream.readable).arrayBuffer();
"#,
    )
    .unwrap();
    assert_eq!(
        vm.eval("JSON.stringify(brotliEvents)").unwrap(),
        r#"["write"]"#
    );
    vm.eval(
        r#"
globalThis.brotliResult = 'pending';
(async () => {
  await brotliWriter.close();
  const bytes = await brotliBytes;
  const source = new ReadableStream({start(c) { c.enqueue(bytes); c.close(); }});
  return await new Response(source.pipeThrough(new DecompressionStream('brotli'))).text();
})().then(value => brotliResult = value, error => brotliResult = error.message);
"#,
    )
    .unwrap();
    advance_page_task_executor_until_eval_equals(
        &mut vm,
        &loader,
        "String(brotliResult !== 'pending')",
        "true",
        "brotli_compression_preserves_backpressure_and_flushes_on_close",
    )
    .await;
    assert_eq!(vm.eval("brotliResult").unwrap(), "AB");
}