tor-browser

observable-every.any.js (7608B)

---

promise_test(async () => {
 const source = new Observable(subscriber => {
   subscriber.next("good");
   subscriber.next("good");
   subscriber.next("good");
   subscriber.complete();
 });

 const result = await source.every((value) => value === "good");

 assert_true(result, "Promise resolves with true if all values pass the predicate");
}, "every(): Promise resolves to true if all values pass the predicate");

promise_test(async () => {
 const source = new Observable(subscriber => {
   subscriber.next("good");
   subscriber.next("good");
   subscriber.next("bad");
   subscriber.complete();
 });

 const result = await source.every((value) => value === "good");

 assert_false(result, "Promise resolves with false if any value fails the predicate");
}, "every(): Promise resolves to false if any value fails the predicate");

promise_test(async () => {
 let tornDown = false;
 let subscriberActiveAfterFailingPredicate = true;
 const source = new Observable(subscriber => {
   subscriber.addTeardown(() => tornDown = true);
   subscriber.next("good");
   subscriber.next("good");
   subscriber.next("bad");
   subscriberActiveAfterFailingPredicate = subscriber.active;
   subscriber.next("good");
   subscriber.complete();
 });

 const result = await source.every((value) => value === "good");

 assert_false(result, "Promise resolves with false if any value fails the predicate");
 assert_false(subscriberActiveAfterFailingPredicate,
     "Subscriber becomes inactive because every() unsubscribed");
}, "every(): Abort the subscription to the source if the predicate does not pass");

promise_test(async () => {
 const logs = [];

 const source = createTestSubject({
   onSubscribe: () => logs.push("subscribed to source"),
   onTeardown: () => logs.push("teardown"),
 });

 const resultPromise = source.every((value, index) => {
   logs.push(`Predicate called with ${value}, ${index}`);
   return true;
 });

 let promiseResolved = false;

 resultPromise.then(() => promiseResolved = true);

 assert_array_equals(logs, ["subscribed to source"],
     "calling every() subscribes to the source immediately");

 source.next("a");
 assert_array_equals(logs, [
   "subscribed to source",
   "Predicate called with a, 0"
 ], "Predicate called with the value and the index");

 source.next("b");
 assert_array_equals(logs, [
   "subscribed to source",
   "Predicate called with a, 0",
   "Predicate called with b, 1",
 ], "Predicate called with the value and the index");

 // wait a tick, just to prove that you have to wait for complete to be called.
 await Promise.resolve();

 assert_false(promiseResolved,
     "Promise should not resolve until after the source completes");

 source.complete();
 assert_array_equals(logs, [
   "subscribed to source",
   "Predicate called with a, 0",
   "Predicate called with b, 1",
   "teardown",
 ], "Teardown function called immediately after the source completes");

 const result = await resultPromise;

 assert_true(result,
     "Promise resolves with true if all values pass the predicate");
}, "every(): Lifecycle checks when all values pass the predicate");

promise_test(async () => {
 const logs = [];

 const source = createTestSubject({
   onSubscribe: () => logs.push("subscribed to source"),
   onTeardown: () => logs.push("teardown"),
 });

 const resultPromise = source.every((value, index) => {
   logs.push(`Predicate called with ${value}, ${index}`);
   return value === "good";
 });

 let promiseResolved = false;

 resultPromise.then(() => promiseResolved = true);

 assert_array_equals(logs, ["subscribed to source"],
     "calling every() subscribes to the source immediately");

 source.next("good");
 source.next("good");
 assert_array_equals(logs, [
   "subscribed to source",
   "Predicate called with good, 0",
   "Predicate called with good, 1",
 ], "Predicate called with the value and the index");

 assert_false(promiseResolved, "Promise should not resolve until after the predicate fails");

 source.next("bad");
 assert_array_equals(logs, [
   "subscribed to source",
   "Predicate called with good, 0",
   "Predicate called with good, 1",
   "Predicate called with bad, 2",
   "teardown",
 ], "Predicate called with the value and the index, failing predicate immediately aborts subscription to source");

 const result = await resultPromise;

 assert_false(result, "Promise resolves with false if any value fails the predicate");
}, "every(): Lifecycle checks when any value fails the predicate");

promise_test(async () => {
 const source = new Observable(subscriber => {
   subscriber.complete();
 });

 const result = await source.every(() => true);

 assert_true(result,
     "Promise resolves with true if the observable completes without " +
     "emitting a value");
}, "every(): Resolves with true if the observable completes without " +
  "emitting a value");

promise_test(async t => {
 const error = new Error("error from source");
 const source = new Observable(subscriber => {
   subscriber.error(error);
 });

 promise_rejects_exactly(t, error, source.every(() => true),
     "Promise rejects with the error emitted from the source observable");
}, "every(): Rejects with any error emitted from the source observable");

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

 const error = new Error("bad value");
 const promise = source.every(value => {
   if (value <= 2) return true;
   throw error;
 });

 promise_rejects_exactly(t, error, promise, "Promise rejects with the " +
     "error thrown from the predicate");
}, "every(): Rejects with any error thrown from the predicate");

promise_test(async () => {
 const indices = [];

 const source = new Observable(subscriber => {
   subscriber.next("a");
   subscriber.next("b");
   subscriber.next("c");
   subscriber.complete();
 });

 const value = await source.every((value, index) => {
   indices.push(index);
   return true;
 });

 assert_array_equals(indices, [0, 1, 2]);

 assert_true(value,
     "Promise resolves with true if all values pass the predicate");
}, "every(): Index is passed into the predicate");

promise_test(async t => {
 const source = new Observable(subscriber => {});

 const controller = new AbortController();
 const promise = source.every(() => true, { signal: controller.signal });
 controller.abort();

 promise_rejects_dom(t, 'AbortError', promise, "Promise rejects with a " +
     "DOMException if the source Observable is aborted");
}, "every(): Rejects with a DOMException if the source Observable is aborted");

function createTestSubject(options) {
 const onTeardown = options?.onTeardown;

 const subscribers = new Set();
 const subject = new Observable(subscriber => {
   options?.onSubscribe?.();
   subscribers.add(subscriber);
   subscriber.addTeardown(() => subscribers.delete(subscriber));
   if (onTeardown) {
     subscriber.addTeardown(onTeardown);
   }
 });

 subject.next = (value) => {
   for (const subscriber of Array.from(subscribers)) {
     subscriber.next(value);
   }
 };
 subject.error = (error) => {
   for (const subscriber of Array.from(subscribers)) {
     subscriber.error(error);
   }
 };
 subject.complete = () => {
   for (const subscriber of Array.from(subscribers)) {
     subscriber.complete();
   }
 };
 subject.subscriberCount = () => {
   return subscribers.size;
 };

 return subject;
}