◐ Shell
clean mode source ↗

stream: update ongoing promise in async iterator return() method · nodejs/node@9b82b15

@@ -475,15 +475,85 @@ promise_test(async () => {

475475

const rs = new ReadableStream();

476476

const it = rs.values();

477477478-

const iterResults = await Promise.allSettled([it.return('return value'), it.next()]);

478+

const resolveOrder = [];

479+

const iterResults = await Promise.allSettled([

480+

it.return('return value').then(result => {

481+

resolveOrder.push('return');

482+

return result;

483+

}),

484+

it.next().then(result => {

485+

resolveOrder.push('next');

486+

return result;

487+

})

488+

]);

479489480490

assert_equals(iterResults[0].status, 'fulfilled', 'return() promise status');

481491

assert_iter_result(iterResults[0].value, 'return value', true, 'return()');

482492483493

assert_equals(iterResults[1].status, 'fulfilled', 'next() promise status');

484494

assert_iter_result(iterResults[1].value, undefined, true, 'next()');

495+496+

assert_array_equals(resolveOrder, ['return', 'next'], 'next() resolves after return()');

485497

}, 'return(); next() [no awaiting]');

486498499+

promise_test(async () => {

500+

let resolveCancelPromise;

501+

const rs = recordingReadableStream({

502+

cancel(reason) {

503+

return new Promise(r => resolveCancelPromise = r);

504+

}

505+

});

506+

const it = rs.values();

507+508+

let returnResolved = false;

509+

const returnPromise = it.return('return value').then(result => {

510+

returnResolved = true;

511+

return result;

512+

});

513+

await flushAsyncEvents();

514+

assert_false(returnResolved, 'return() should not resolve while cancel() promise is pending');

515+516+

resolveCancelPromise();

517+

const iterResult1 = await returnPromise;

518+

assert_iter_result(iterResult1, 'return value', true, 'return()');

519+520+

const iterResult2 = await it.next();

521+

assert_iter_result(iterResult2, undefined, true, 'next()');

522+

}, 'return(); next() with delayed cancel()');

523+524+

promise_test(async () => {

525+

let resolveCancelPromise;

526+

const rs = recordingReadableStream({

527+

cancel(reason) {

528+

return new Promise(r => resolveCancelPromise = r);

529+

}

530+

});

531+

const it = rs.values();

532+533+

const resolveOrder = [];

534+

const returnPromise = it.return('return value').then(result => {

535+

resolveOrder.push('return');

536+

return result;

537+

});

538+

const nextPromise = it.next().then(result => {

539+

resolveOrder.push('next');

540+

return result;

541+

});

542+543+

assert_array_equals(rs.events, ['cancel', 'return value'], 'return() should call cancel()');

544+

assert_array_equals(resolveOrder, [], 'return() should not resolve before cancel() resolves');

545+546+

resolveCancelPromise();

547+

const iterResult1 = await returnPromise;

548+

assert_iter_result(iterResult1, 'return value', true, 'return() should resolve with original reason');

549+

const iterResult2 = await nextPromise;

550+

assert_iter_result(iterResult2, undefined, true, 'next() should resolve with done result');

551+552+

assert_array_equals(rs.events, ['cancel', 'return value'], 'no pull() after cancel()');

553+

assert_array_equals(resolveOrder, ['return', 'next'], 'next() should resolve after return() resolves');

554+555+

}, 'return(); next() with delayed cancel() [no awaiting]');

556+487557

promise_test(async () => {

488558

const rs = new ReadableStream();

489559

const it = rs.values();

@@ -499,13 +569,25 @@ promise_test(async () => {

499569

const rs = new ReadableStream();

500570

const it = rs.values();

501571502-

const iterResults = await Promise.allSettled([it.return('return value 1'), it.return('return value 2')]);

572+

const resolveOrder = [];

573+

const iterResults = await Promise.allSettled([

574+

it.return('return value 1').then(result => {

575+

resolveOrder.push('return 1');

576+

return result;

577+

}),

578+

it.return('return value 2').then(result => {

579+

resolveOrder.push('return 2');

580+

return result;

581+

})

582+

]);

503583504584

assert_equals(iterResults[0].status, 'fulfilled', '1st return() promise status');

505585

assert_iter_result(iterResults[0].value, 'return value 1', true, '1st return()');

506586507587

assert_equals(iterResults[1].status, 'fulfilled', '2nd return() promise status');

508588

assert_iter_result(iterResults[1].value, 'return value 2', true, '1st return()');

589+590+

assert_array_equals(resolveOrder, ['return 1', 'return 2'], '2nd return() resolves after 1st return()');

509591

}, 'return(); return() [no awaiting]');

510592511593

test(() => {