|
|
import { Cancellation } from "../Cancellation";
|
|
|
import { CancellationAggregate } from "../CancellationAggregate";
|
|
|
import { delay, notImplemented } from "../safe";
|
|
|
import { test } from "./TestTraits";
|
|
|
|
|
|
test("standalone cancellation", async t => {
|
|
|
|
|
|
let doCancel: (e: any) => void = notImplemented;
|
|
|
|
|
|
const ct = new Cancellation(cancel => {
|
|
|
doCancel = cancel;
|
|
|
});
|
|
|
|
|
|
let counter = 0;
|
|
|
const reason = "BILL";
|
|
|
|
|
|
t.true(ct.isSupported(), "Cancellation must be supported");
|
|
|
t.false(ct.isRequested(), "Cancellation shouldn't be requested");
|
|
|
ct.throwIfRequested();
|
|
|
t.pass("The exception shouldn't be thrown unless the cancellation is requested");
|
|
|
|
|
|
ct.register(() => counter++);
|
|
|
t.equals(counter, 0, "counter should be zero");
|
|
|
|
|
|
ct.register(() => counter++).destroy();
|
|
|
|
|
|
doCancel(reason);
|
|
|
|
|
|
t.true(ct.isRequested(), "Cancellation should be requested");
|
|
|
t.equals(counter, 1, "The registered callback should be triggered");
|
|
|
|
|
|
ct.register(() => counter++);
|
|
|
t.equals(counter, 2, "The callback should be triggered immediately");
|
|
|
|
|
|
let msg;
|
|
|
ct.register(e => msg = e);
|
|
|
t.equals(msg, reason, "The cancellation reason should be passed to callback");
|
|
|
|
|
|
try {
|
|
|
msg = null;
|
|
|
ct.throwIfRequested();
|
|
|
t.fail("The exception should be thrown");
|
|
|
} catch (e) {
|
|
|
msg = e;
|
|
|
}
|
|
|
t.equals(msg, reason, "The cancellation reason should be catched");
|
|
|
});
|
|
|
|
|
|
test("async cancellation", async t => {
|
|
|
|
|
|
const ct = new Cancellation(cancel => {
|
|
|
cancel("STOP!");
|
|
|
});
|
|
|
|
|
|
try {
|
|
|
await delay(0, ct);
|
|
|
t.fail("Should thow the exception");
|
|
|
} catch (e) {
|
|
|
t.equals(e, "STOP!", "Should throw the cancellation reason");
|
|
|
}
|
|
|
});
|
|
|
|
|
|
test("cancel with external event", async t => {
|
|
|
const ct = new Cancellation(cancel => {
|
|
|
setTimeout(x => cancel("STOP!"), 0);
|
|
|
});
|
|
|
|
|
|
try {
|
|
|
await delay(10000, ct);
|
|
|
t.fail("Should thow the exception");
|
|
|
} catch (e) {
|
|
|
t.equals(e, "STOP!", "Should throw the cancellation reason");
|
|
|
}
|
|
|
});
|
|
|
|
|
|
test("operation normal flow", async t => {
|
|
|
|
|
|
let htimeout;
|
|
|
const ct = new Cancellation(cancel => {
|
|
|
htimeout = setTimeout(() => cancel("STOP!"), 1000);
|
|
|
});
|
|
|
|
|
|
try {
|
|
|
await delay(0, ct);
|
|
|
t.pass("Should pass");
|
|
|
} finally {
|
|
|
clearTimeout(htimeout);
|
|
|
}
|
|
|
});
|
|
|
|
|
|
test("combine cancellations", t => {
|
|
|
const ct1 = new Cancellation(cancel => {
|
|
|
cancel("cancelled");
|
|
|
});
|
|
|
|
|
|
const ct2 = new Cancellation(() => {});
|
|
|
|
|
|
const cct1 = Cancellation.combine(Cancellation.none, ct1);
|
|
|
|
|
|
t.equals(cct1, ct1, "Cancellation.combine should filter out Cancellation.none tokens");
|
|
|
|
|
|
const cct2 = Cancellation.combine(Cancellation.none, ct1, ct2);
|
|
|
|
|
|
t.assert(cct2 instanceof CancellationAggregate, "Cancellation.combine should return CancellationAggregate");
|
|
|
t.true(cct2.isRequested(), "CancellationAggregate should return isRequested true if any of cancellations is requested");
|
|
|
});
|
|
|
|
