multiple-propagation.any.js (6881B)
1 // META: global=window,worker,shadowrealm 2 // META: script=../resources/test-utils.js 3 // META: script=../resources/recording-streams.js 4 'use strict'; 5 6 const error1 = new Error('error1!'); 7 error1.name = 'error1'; 8 9 const error2 = new Error('error2!'); 10 error2.name = 'error2'; 11 12 function createErroredWritableStream(t) { 13 return Promise.resolve().then(() => { 14 const ws = recordingWritableStream({ 15 start(c) { 16 c.error(error2); 17 } 18 }); 19 20 const writer = ws.getWriter(); 21 return promise_rejects_exactly(t, error2, writer.closed, 'the writable stream must be errored with error2') 22 .then(() => { 23 writer.releaseLock(); 24 assert_array_equals(ws.events, []); 25 return ws; 26 }); 27 }); 28 } 29 30 promise_test(t => { 31 const rs = recordingReadableStream({ 32 start(c) { 33 c.error(error1); 34 } 35 }); 36 const ws = recordingWritableStream({ 37 start(c) { 38 c.error(error2); 39 } 40 }); 41 42 // Trying to abort a stream that is erroring will give the writable's error 43 return promise_rejects_exactly(t, error2, rs.pipeTo(ws), 'pipeTo must reject with the writable stream\'s error').then(() => { 44 assert_array_equals(rs.events, []); 45 assert_array_equals(ws.events, []); 46 47 return Promise.all([ 48 promise_rejects_exactly(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'), 49 promise_rejects_exactly(t, error2, ws.getWriter().closed, 'the writable stream must be errored with error2') 50 ]); 51 }); 52 53 }, 'Piping from an errored readable stream to an erroring writable stream'); 54 55 promise_test(t => { 56 const rs = recordingReadableStream({ 57 start(c) { 58 c.error(error1); 59 } 60 }); 61 62 return createErroredWritableStream(t) 63 .then(ws => promise_rejects_exactly(t, error1, rs.pipeTo(ws), 'pipeTo must reject with the readable stream\'s error')) 64 .then(() => { 65 assert_array_equals(rs.events, []); 66 67 return promise_rejects_exactly(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'); 68 }); 69 }, 'Piping from an errored readable stream to an errored writable stream'); 70 71 promise_test(t => { 72 const rs = recordingReadableStream({ 73 start(c) { 74 c.error(error1); 75 } 76 }); 77 const ws = recordingWritableStream({ 78 start(c) { 79 c.error(error2); 80 } 81 }); 82 83 return promise_rejects_exactly(t, error1, rs.pipeTo(ws, { preventAbort: true }), 84 'pipeTo must reject with the readable stream\'s error') 85 .then(() => { 86 assert_array_equals(rs.events, []); 87 assert_array_equals(ws.events, []); 88 89 return Promise.all([ 90 promise_rejects_exactly(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'), 91 promise_rejects_exactly(t, error2, ws.getWriter().closed, 'the writable stream must be errored with error2') 92 ]); 93 }); 94 95 }, 'Piping from an errored readable stream to an erroring writable stream; preventAbort = true'); 96 97 promise_test(t => { 98 const rs = recordingReadableStream({ 99 start(c) { 100 c.error(error1); 101 } 102 }); 103 return createErroredWritableStream(t) 104 .then(ws => promise_rejects_exactly(t, error1, rs.pipeTo(ws, { preventAbort: true }), 105 'pipeTo must reject with the readable stream\'s error')) 106 .then(() => { 107 assert_array_equals(rs.events, []); 108 109 return promise_rejects_exactly(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'); 110 }); 111 112 }, 'Piping from an errored readable stream to an errored writable stream; preventAbort = true'); 113 114 promise_test(t => { 115 const rs = recordingReadableStream({ 116 start(c) { 117 c.error(error1); 118 } 119 }); 120 const ws = recordingWritableStream(); 121 const writer = ws.getWriter(); 122 const closePromise = writer.close(); 123 writer.releaseLock(); 124 125 return promise_rejects_exactly(t, error1, rs.pipeTo(ws), 'pipeTo must reject with the readable stream\'s error').then(() => { 126 assert_array_equals(rs.events, []); 127 assert_array_equals(ws.events, ['abort', error1]); 128 129 return Promise.all([ 130 promise_rejects_exactly(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'), 131 promise_rejects_exactly(t, error1, ws.getWriter().closed, 132 'closed must reject with error1'), 133 promise_rejects_exactly(t, error1, closePromise, 134 'close() must reject with error1') 135 ]); 136 }); 137 138 }, 'Piping from an errored readable stream to a closing writable stream'); 139 140 promise_test(t => { 141 const rs = recordingReadableStream({ 142 start(c) { 143 c.error(error1); 144 } 145 }); 146 const ws = recordingWritableStream(); 147 const writer = ws.getWriter(); 148 const closePromise = writer.close(); 149 writer.releaseLock(); 150 151 return flushAsyncEvents().then(() => { 152 return promise_rejects_exactly(t, error1, rs.pipeTo(ws), 'pipeTo must reject with the readable stream\'s error').then(() => { 153 assert_array_equals(rs.events, []); 154 assert_array_equals(ws.events, ['close']); 155 156 return Promise.all([ 157 promise_rejects_exactly(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'), 158 ws.getWriter().closed, 159 closePromise 160 ]); 161 }); 162 }); 163 164 }, 'Piping from an errored readable stream to a closed writable stream'); 165 166 promise_test(t => { 167 const rs = recordingReadableStream({ 168 start(c) { 169 c.close(); 170 } 171 }); 172 const ws = recordingWritableStream({ 173 start(c) { 174 c.error(error1); 175 } 176 }); 177 178 return promise_rejects_exactly(t, error1, rs.pipeTo(ws), 'pipeTo must reject with the writable stream\'s error').then(() => { 179 assert_array_equals(rs.events, []); 180 assert_array_equals(ws.events, []); 181 182 return Promise.all([ 183 rs.getReader().closed, 184 promise_rejects_exactly(t, error1, ws.getWriter().closed, 'the writable stream must be errored with error1') 185 ]); 186 }); 187 188 }, 'Piping from a closed readable stream to an erroring writable stream'); 189 190 promise_test(t => { 191 const rs = recordingReadableStream({ 192 start(c) { 193 c.close(); 194 } 195 }); 196 return createErroredWritableStream(t) 197 .then(ws => promise_rejects_exactly(t, error2, rs.pipeTo(ws), 'pipeTo must reject with the writable stream\'s error')) 198 .then(() => { 199 assert_array_equals(rs.events, []); 200 201 return rs.getReader().closed; 202 }); 203 204 }, 'Piping from a closed readable stream to an errored writable stream'); 205 206 promise_test(() => { 207 const rs = recordingReadableStream({ 208 start(c) { 209 c.close(); 210 } 211 }); 212 const ws = recordingWritableStream(); 213 const writer = ws.getWriter(); 214 writer.close(); 215 writer.releaseLock(); 216 217 return rs.pipeTo(ws).then(() => { 218 assert_array_equals(rs.events, []); 219 assert_array_equals(ws.events, ['close']); 220 221 return Promise.all([ 222 rs.getReader().closed, 223 ws.getWriter().closed 224 ]); 225 }); 226 227 }, 'Piping from a closed readable stream to a closed writable stream');