dom/observable/tentative/observable-toArray.any.js

// Because we test that the global error handler is called at various times.
setup({allow_uncaught_exception: true});

promise_test(async () => {
  const observable = new Observable(subscriber => {
    subscriber.next(1);
    subscriber.next(2);
    subscriber.next(3);
    subscriber.complete();
  });

  const array = await observable.toArray();
  assert_array_equals(array, [1, 2, 3]);
}, "toArray(): basic next/complete");

promise_test(async t => {
  let errorReported = null;
  let innerSubscriber = null;
  self.addEventListener('error', e => errorReported = e, {once: true});

  const error = new Error("custom error");
  const observable = new Observable(subscriber => {
    innerSubscriber = subscriber;
    subscriber.error(error);
  });

  try {
    const array = await observable.toArray();
    assert_unreached("toArray() promise must not resolve");
  } catch (e) {
    assert_equals(e, error);
    assert_equals(errorReported, null);

    // Calls to `error()` after the subscription is closed still report the
    // exception.
    innerSubscriber.error(error);
    assert_not_equals(errorReported, null, "Exception was reported to global");
    assert_true(errorReported.message.includes("custom error"), "Error message matches");
    assert_greater_than(errorReported.lineno, 0, "Error lineno is greater than 0");
    assert_greater_than(errorReported.colno, 0, "Error lineno is greater than 0");
    assert_equals(errorReported.error, error, "Error object is equivalent");
  }
}, "toArray(): first error() rejects promise; subsequent error()s report the exceptions");

promise_test(async t => {
  let errorReported = null;
  let innerSubscriber = null;
  self.addEventListener('error', e => errorReported = e, {once: true});

  const error = new Error("custom error");
  const observable = new Observable(subscriber => {
    innerSubscriber = subscriber;
    subscriber.complete();
  });

  const array = await observable.toArray();
  assert_array_equals(array, []);
  assert_equals(errorReported, null);

  // Calls to `error()` after the subscription is closed still report the
  // exception.
  innerSubscriber.error(error);
  assert_not_equals(errorReported, null, "Exception was reported to global");
  assert_true(errorReported.message.includes("custom error"), "Error message matches");
  assert_greater_than(errorReported.lineno, 0, "Error lineno is greater than 0");
  assert_greater_than(errorReported.colno, 0, "Error lineno is greater than 0");
  assert_equals(errorReported.error, error, "Error object is equivalent");
}, "toArray(): complete() resolves promise; subsequent error()s report the exceptions");

promise_test(async () => {
  // This tracks whether `postSubscriptionPromise` has had its then handler run.
  // This helps us keep track of the timing/ordering of everything. Calling a
  // Promise-returning operator with an aborted signal must *immediately* reject
  // the returned Promise, which means code "awaiting" it should run before any
  // subsequent Promise resolution/rejection handlers are run.
  let postSubscriptionPromiseResolved = false;
  let subscriptionImmediatelyInactive = false;

  const observable = new Observable(subscriber => {
    const inactive = !subscriber.active;
    subscriptionImmediatelyInactive = inactive;
  });

  const rejectedPromise = observable.toArray({signal: AbortSignal.abort()})
  .then(() => {
    assert_unreached("Operator promise must not resolve its abort signal is " +
                     "rejected");
  }, () => {
    // See the documentation above. The rejection handler (i.e., this code) for
    // immediately-aborted operator Promises runs before any later-scheduled
    // Promise resolution/rejections.
    assert_false(postSubscriptionPromiseResolved,
        "Operator promise rejects before later promise");
  });
  const postSubscriptionPromise =
      Promise.resolve().then(() => postSubscriptionPromiseResolved = true);

  await rejectedPromise;
}, "toArray(): Subscribing with an aborted signal returns an immediately " +
   "rejected promise");

promise_test(async () => {
  let postSubscriptionPromiseResolved = false;

  const observable = new Observable(subscriber => {});
  const controller = new AbortController();
  const arrayPromise = observable.toArray({signal: controller.signal})
  .then(() => {
    assert_unreached("Operator promise must not resolve if its abort signal " +
    "is rejected");
  }, () => {
    assert_false(postSubscriptionPromiseResolved,
                 "controller.abort() synchronously rejects the operator " +
                 "Promise");
  });

  // This must synchronously reject `arrayPromise`, scheduling in the next
  // microtask.
  controller.abort();
  Promise.resolve().then(value => postSubscriptionPromiseResolved = true);

  await arrayPromise;
}, "toArray(): Aborting the passed-in signal rejects the returned promise");

// See https://github.com/WICG/observable/issues/96 for discussion about this.
promise_test(async () => {
  const results = [];

  const observable = new Observable(subscriber => {
    results.push(`Subscribed. active: ${subscriber.active}`);

    subscriber.signal.addEventListener('abort', e => {
      results.push("Inner signal abort event");
      Promise.resolve("Inner signal Promise").then(value => results.push(value));
    });

    subscriber.addTeardown(() => {
      results.push("Teardown");
      Promise.resolve("Teardown Promise").then(value => results.push(value));
    });
  });

  const controller = new AbortController();
  controller.signal.addEventListener('abort', e => {
    results.push("Outer signal abort event");
    Promise.resolve("Outer signal Promise").then(value => results.push(value));
  });

  // Subscribe.
  observable.toArray({signal: controller.signal});
  controller.abort();

  assert_array_equals(results, [
    "Subscribed. active: true",
    "Inner signal abort event",
    "Teardown",
    "Outer signal abort event",
  ], "Events and teardowns are fired in the right ordered");

  // Everything microtask above should be queued up by now, so queue one more
  // final microtask that will run after all of the others, wait for it, and the
  // check `results` is right.
  await Promise.resolve();
  assert_array_equals(results, [
    "Subscribed. active: true",
    "Inner signal abort event",
    "Teardown",
    "Outer signal abort event",
    "Inner signal Promise",
    "Teardown Promise",
    "Outer signal Promise",
  ], "Promises resolve in the right order");
}, "Operator Promise abort ordering");