tor-browser

pipe-through.any.js (10144B)

---

// META: global=window,worker,shadowrealm
// META: script=../resources/rs-utils.js
// META: script=../resources/test-utils.js
// META: script=../resources/recording-streams.js
'use strict';

function duckTypedPassThroughTransform() {
 let enqueueInReadable;
 let closeReadable;

 return {
   writable: new WritableStream({
     write(chunk) {
       enqueueInReadable(chunk);
     },

     close() {
       closeReadable();
     }
   }),

   readable: new ReadableStream({
     start(c) {
       enqueueInReadable = c.enqueue.bind(c);
       closeReadable = c.close.bind(c);
     }
   })
 };
}

function uninterestingReadableWritablePair() {
 return { writable: new WritableStream(), readable: new ReadableStream() };
}

promise_test(() => {
 const readableEnd = sequentialReadableStream(5).pipeThrough(duckTypedPassThroughTransform());

 return readableStreamToArray(readableEnd).then(chunks =>
   assert_array_equals(chunks, [1, 2, 3, 4, 5]), 'chunks should match');
}, 'Piping through a duck-typed pass-through transform stream should work');

promise_test(() => {
 const transform = {
   writable: new WritableStream({
     start(c) {
       c.error(new Error('this rejection should not be reported as unhandled'));
     }
   }),
   readable: new ReadableStream()
 };

 sequentialReadableStream(5).pipeThrough(transform);

 // The test harness should complain about unhandled rejections by then.
 return flushAsyncEvents();

}, 'Piping through a transform errored on the writable end does not cause an unhandled promise rejection');

test(() => {
 let calledPipeTo = false;
 class BadReadableStream extends ReadableStream {
   pipeTo() {
     calledPipeTo = true;
   }
 }

 const brs = new BadReadableStream({
   start(controller) {
     controller.close();
   }
 });
 const readable = new ReadableStream();
 const writable = new WritableStream();
 const result = brs.pipeThrough({ readable, writable });

 assert_false(calledPipeTo, 'the overridden pipeTo should not have been called');
 assert_equals(result, readable, 'return value should be the passed readable property');
}, 'pipeThrough should not call pipeTo on this');

test(t => {
 let calledFakePipeTo = false;
 const realPipeTo = ReadableStream.prototype.pipeTo;
 t.add_cleanup(() => {
   ReadableStream.prototype.pipeTo = realPipeTo;
 });
 ReadableStream.prototype.pipeTo = () => {
   calledFakePipeTo = true;
 };
 const rs = new ReadableStream();
 const readable = new ReadableStream();
 const writable = new WritableStream();
 const result = rs.pipeThrough({ readable, writable });

 assert_false(calledFakePipeTo, 'the monkey-patched pipeTo should not have been called');
 assert_equals(result, readable, 'return value should be the passed readable property');

}, 'pipeThrough should not call pipeTo on the ReadableStream prototype');

const badReadables = [null, undefined, 0, NaN, true, 'ReadableStream', Object.create(ReadableStream.prototype)];
for (const readable of badReadables) {
 test(() => {
   assert_throws_js(TypeError,
                    ReadableStream.prototype.pipeThrough.bind(readable, uninterestingReadableWritablePair()),
                    'pipeThrough should throw');
 }, `pipeThrough should brand-check this and not allow '${readable}'`);

 test(() => {
   const rs = new ReadableStream();
   let writableGetterCalled = false;
   assert_throws_js(
     TypeError,
     () => rs.pipeThrough({
       get writable() {
         writableGetterCalled = true;
         return new WritableStream();
       },
       readable
     }),
     'pipeThrough should brand-check readable'
   );
   assert_false(writableGetterCalled, 'writable should not have been accessed');
 }, `pipeThrough should brand-check readable and not allow '${readable}'`);
}

const badWritables = [null, undefined, 0, NaN, true, 'WritableStream', Object.create(WritableStream.prototype)];
for (const writable of badWritables) {
 test(() => {
   const rs = new ReadableStream({
     start(c) {
       c.close();
     }
   });
   let readableGetterCalled = false;
   assert_throws_js(TypeError, () => rs.pipeThrough({
     get readable() {
       readableGetterCalled = true;
       return new ReadableStream();
     },
     writable
   }),
                 'pipeThrough should brand-check writable');
   assert_true(readableGetterCalled, 'readable should have been accessed');
 }, `pipeThrough should brand-check writable and not allow '${writable}'`);
}

test(t => {
 const error = new Error();
 error.name = 'custom';

 const rs = new ReadableStream({
   pull: t.unreached_func('pull should not be called')
 }, { highWaterMark: 0 });

 const throwingWritable = {
   readable: rs,
   get writable() {
     throw error;
   }
 };
 assert_throws_exactly(error,
                       () => ReadableStream.prototype.pipeThrough.call(rs, throwingWritable, {}),
                       'pipeThrough should rethrow the error thrown by the writable getter');

 const throwingReadable = {
   get readable() {
     throw error;
   },
   writable: {}
 };
 assert_throws_exactly(error,
                       () => ReadableStream.prototype.pipeThrough.call(rs, throwingReadable, {}),
                       'pipeThrough should rethrow the error thrown by the readable getter');

}, 'pipeThrough should rethrow errors from accessing readable or writable');

const badSignals = [null, 0, NaN, true, 'AbortSignal', Object.create(AbortSignal.prototype)];
for (const signal of badSignals) {
 test(() => {
   const rs = new ReadableStream();
   assert_throws_js(TypeError, () => rs.pipeThrough(uninterestingReadableWritablePair(), { signal }),
                    'pipeThrough should throw');
 }, `invalid values of signal should throw; specifically '${signal}'`);
}

test(() => {
 const rs = new ReadableStream();
 const controller = new AbortController();
 const signal = controller.signal;
 rs.pipeThrough(uninterestingReadableWritablePair(), { signal });
}, 'pipeThrough should accept a real AbortSignal');

test(() => {
 const rs = new ReadableStream();
 rs.getReader();
 assert_throws_js(TypeError, () => rs.pipeThrough(uninterestingReadableWritablePair()),
                  'pipeThrough should throw');
}, 'pipeThrough should throw if this is locked');

test(() => {
 const rs = new ReadableStream();
 const writable = new WritableStream();
 const readable = new ReadableStream();
 writable.getWriter();
 assert_throws_js(TypeError, () => rs.pipeThrough({writable, readable}),
                  'pipeThrough should throw');
}, 'pipeThrough should throw if writable is locked');

test(() => {
 const rs = new ReadableStream();
 const writable = new WritableStream();
 const readable = new ReadableStream();
 readable.getReader();
 assert_equals(rs.pipeThrough({ writable, readable }), readable,
               'pipeThrough should not throw');
}, 'pipeThrough should not care if readable is locked');

promise_test(() => {
 const rs = recordingReadableStream();
 const writable = new WritableStream({
   start(controller) {
     controller.error();
   }
 });
 const readable = new ReadableStream();
 rs.pipeThrough({ writable, readable }, { preventCancel: true });
 return flushAsyncEvents(0).then(() => {
   assert_array_equals(rs.events, ['pull'], 'cancel should not have been called');
 });
}, 'preventCancel should work');

promise_test(() => {
 const rs = new ReadableStream({
   start(controller) {
     controller.close();
   }
 });
 const writable = recordingWritableStream();
 const readable = new ReadableStream();
 rs.pipeThrough({ writable, readable }, { preventClose: true });
 return flushAsyncEvents(0).then(() => {
   assert_array_equals(writable.events, [], 'writable should not be closed');
 });
}, 'preventClose should work');

promise_test(() => {
 const rs = new ReadableStream({
   start(controller) {
     controller.error();
   }
 });
 const writable = recordingWritableStream();
 const readable = new ReadableStream();
 rs.pipeThrough({ writable, readable }, { preventAbort: true });
 return flushAsyncEvents(0).then(() => {
   assert_array_equals(writable.events, [], 'writable should not be aborted');
 });
}, 'preventAbort should work');

test(() => {
 const rs = new ReadableStream();
 const readable = new ReadableStream();
 const writable = new WritableStream();
 assert_throws_js(TypeError, () => rs.pipeThrough({readable, writable}, {
   get preventAbort() {
     writable.getWriter();
   }
 }), 'pipeThrough should throw');
}, 'pipeThrough() should throw if an option getter grabs a writer');

test(() => {
 const rs = new ReadableStream();
 const readable = new ReadableStream();
 const writable = new WritableStream();
 rs.pipeThrough({readable, writable}, null);
}, 'pipeThrough() should not throw if option is null');

test(() => {
 const rs = new ReadableStream();
 const readable = new ReadableStream();
 const writable = new WritableStream();
 rs.pipeThrough({readable, writable}, {signal:undefined});
}, 'pipeThrough() should not throw if signal is undefined');

function tryPipeThrough(pair, options)
{
 const rs = new ReadableStream();
 if (!pair)
   pair = {readable:new ReadableStream(), writable:new WritableStream()};
 try {
   rs.pipeThrough(pair, options)
 } catch (e) {
   return e;
 }
}

test(() => {
 let result = tryPipeThrough({
   get readable() {
     return new ReadableStream();
   },
   get writable() {
     throw "writable threw";
   }
 }, { });
 assert_equals(result, "writable threw");

 result = tryPipeThrough({
   get readable() {
     throw "readable threw";
   },
   get writable() {
     throw "writable threw";
   }
 }, { });
 assert_equals(result, "readable threw");

 result = tryPipeThrough({
   get readable() {
     throw "readable threw";
   },
   get writable() {
     throw "writable threw";
   }
 }, {
   get preventAbort() {
     throw "preventAbort threw";
   }
 });
 assert_equals(result, "readable threw");

}, 'pipeThrough() should throw if readable/writable getters throw');