<!DOCTYPE html>
<script src='../../resources/testharness.js'></script>
<script src='../../resources/testharnessreport.js'></script>
<script src='resources/streams-utils.js'></script>
<script>
// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3

var test1 = async_test('Aborting a WritableStream immediately prevents future writes');
test1.step(function() {
    var chunks = [];
    var ws = new WritableStream({
        write: function(chunk) {
            chunks.push(chunk);
        }
    });

    setTimeout(test1.step_func(function() {
        ws.abort();
        ws.write(1);
        ws.write(2);
        assert_array_equals(chunks, [], 'no chunks are written');
        test1.done();
    }), 0);
});

var test2 = async_test('Aborting a WritableStream prevents further writes after any that are in progress');
test2.step(function() {
    var chunks = [];
    var ws = new WritableStream({
        write: function(chunk) {
            chunks.push(chunk);
            return new Promise(test2.step_func(function(resolve) { setTimeout(test2.step_func(function() { resolve(); }), 200); }));
        }
    });

    setTimeout(test2.step_func(function() {
        ws.write(1);
        ws.write(2);
        ws.write(3);
        ws.abort();
        ws.write(4);
        ws.write(5);

        setTimeout(test2.step_func(function () {
            assert_array_equals(chunks, [1], 'only the single in-progress chunk gets written');
            test2.done();
        }), 500);
    }), 0);
});

var test3 = async_test('Fulfillment value of ws.abort() call must be undefined even if the underlying sink returns a non-undefined value');
test3.step(function() {
    var ws = new WritableStream({
        abort: function() {
            return 'Hello';
        }
    });

    var abortPromise = ws.abort('a');
    abortPromise.then(test3.step_func(function(value) {
        assert_equals(value, undefined, 'fulfillment value must be undefined');
        test3.done();
    })).catch(test3.step_func(function() { assert_unreached('abortPromise is rejected'); }));
});

var test4 = async_test('WritableStream if sink\'s abort throws, the promise returned by ws.abort() rejects');
test4.step(function() {
    var errorInSinkAbort = new Error('Sorry, it just wasn\'t meant to be.');
    var ws = new WritableStream({
        abort: function() {
            throw errorInSinkAbort;
        }
    });

    var abortPromise = ws.abort(undefined);
    abortPromise.then(
        test4.step_func(function() { assert_unreached('abortPromise is fulfilled unexpectedly'); }),
        test4.step_func(function(r) {
            assert_equals(r, errorInSinkAbort, 'rejection reason of abortPromise must be errorInSinkAbort');
            test4.done();
        })
    );
});

test(function() {
    var recordedReason;
    var ws = new WritableStream({
        abort: function(reason) {
            recordedReason = reason;
        }
    });

    var passedReason = new Error('Sorry, it just wasn\'t meant to be.');
    ws.abort(passedReason);

    assert_equals(recordedReason, passedReason);
}, 'Aborting a WritableStream passes through the given reason');

var test5 = async_test('Aborting a WritableStream puts it in an errored state, with stored error equal to the abort reason');
test5.step(function() {
    var events = 0;
    var recordedReason;
    var ws = new WritableStream();

    var passedReason = new Error('Sorry, it just wasn\'t meant to be.');
    ws.abort(passedReason);

    assert_equals(ws.state, 'errored', 'state should be errored');

    ws.write().then(
        test5.step_func(function() { assert_unreached('writing should not succeed'); }),
        test5.step_func(function(r) {
            assert_equals(r, passedReason, 'writing should reject with the given reason');
            assert_equals(++events, 1);
        })
    );

    ws.close().then(
        test5.step_func(function() { assert_unreached('closing should not succeed'); }),
        test5.step_func(function(r) {
            assert_equals(r, passedReason, 'closing should reject with the given reason');
            assert_equals(++events, 2);
        })
    );

    ws.abort().then(
        test5.step_func(function() { assert_unreached('aborting a second time should not succeed'); }),
        test5.step_func(function(r) {
            assert_equals(r, passedReason, 'aborting a second time should reject with the given reason');
            assert_equals(++events, 3);
        })
    );

    ws.closed.then(
        test5.step_func(function() { assert_unreached('closed promise should not be fulfilled'); }),
        test5.step_func(function(r) {
            assert_equals(r, passedReason, 'closed promise should be rejected with the given reason');
            assert_equals(++events, 4);
            test5.done();
        })
    );
});

var test6 = async_test('Aborting a WritableStream causes any outstanding ready promises to be fulfilled immediately');
test6.step(function() {
    var writeCalled = false;
    var recordedReason;
    var ws = new WritableStream({
        write: function(chunk) {
            writeCalled = true;
            return new Promise(test6.step_func(function() { })); // forever-pending, so normally .ready would not fulfill.
        }
    });
    ws.write('a');
    assert_equals(ws.state, 'waiting', 'state should be waiting');

    ws.ready.then(test6.step_func(function() {
        assert_equals(ws.state, 'errored', 'state should now be errored');
        assert_false(writeCalled);
        test6.done();
    }));

    var passedReason = new Error('Sorry, it just wasn\'t meant to be.');
    ws.abort(passedReason);
});

var test7 = async_test('Aborting a WritableStream causes any outstanding write() promises to be rejected with the abort reason');
test7.step(function() {
    var ws = new WritableStream();

    ws.write('a').then(
        test7.step_func(function() { assert_unreached('writing should not succeed'); }),
        test7.step_func(function(r) {
            assert_equals(r, passedReason, 'writing should reject with the given reason');
            test7.done();
        })
    );

    var passedReason = new Error('Sorry, it just wasn\'t meant to be.');
    ws.abort(passedReason);
});

var test8 = async_test('Closing but then immediately aborting a WritableStream causes the stream to error');
test8.step(function() {
    var ws = new WritableStream();

    ws.close();

    var passedReason = new Error('Sorry, it just wasn\'t meant to be.');
    ws.abort(passedReason);

    assert_equals(ws.state, 'errored');

    ws.closed.then(
        test8.step_func(function() { assert_unreached('the stream should not close successfully'); }),
        test8.step_func(function(r) {
            assert_equals(r, passedReason, 'the stream should be errored with the given reason');
            test8.done();
        })
    );
});

var test9 = async_test('Closing a WritableStream and aborting it while it closes causes the stream to error');
test9.step(function() {
    var ws = new WritableStream({
        close: function() {
            return new Promise(test9.step_func(function() { })); // forever-pending
        }
    });

    ws.close();

    var passedReason = new Error('Sorry, it just wasn\'t meant to be.');

    setTimeout(test9.step_func(function() {
        assert_equals(ws.state, 'closing');

        ws.abort(passedReason);

        assert_equals(ws.state, 'errored');
    }), 200);

    ws.closed.then(
        test9.step_func(function() { assert_unreached('the stream should not close successfully'); }),
        test9.step_func(function(r) {
            assert_equals(r, passedReason, 'the stream should be errored with the given reason');
            test9.done();
        })
    );
});

var test10 = async_test('Aborting a WritableStream after it is closed is a no-op');
test10.step(function() {
    var ws = new WritableStream();

    ws.close();

    setTimeout(test10.step_func(function() {
        assert_equals(ws.state, 'closed');

        ws.abort().then(
            test10.step_func(function(v) {
                assert_equals(v, undefined, 'abort promise should fulfill with undefined');
                test10.done();
            }),
            test10.step_func(assert_unreached)
        );

        assert_equals(ws.state, 'closed', 'state stays closed');
    }), 0);
});

var test11 = async_test('WritableStream should call underlying sink\'s close if no abort is supplied');
test11.step(function() {
    var ws = new WritableStream({
        close: function() {
            assert_equals(arguments.length, 0, 'close() was called (with no arguments)');
            test11.done();
        }
    });

    ws.abort();
});
</script>