rsxjs/__tests__/integration/channel/test-select.js

Resilience Extensions for JS.

/**
 * @file tests/channel/test-select.js
 * @copyright 2018-present Karim Alibhai. All rights reserved.
 */

import { test } from "../../helpers";

import { makeChan, select } from "../../../";

test("blocking select on unbuffered channel", async (t) => {
  const chanA = makeChan();
  const chanB = makeChan();

  setTimeout(() => chanB.put("test"), 0);

  const ret = await select({
    [chanA]: (a) => ({ a }),
    [chanB]: (b) => ({ b }),
  });

  t.deepEqual(ret, { b: "test" });
});

test("blocking select on buffered channel", async (t) => {
  const chanA = makeChan({
    bufferSize: 2,
  });
  const chanB = makeChan({
    bufferSize: 2,
  });

  setTimeout(() => chanB.put("test"), 0);

  const ret = await select({
    [chanA]: (a) => ({ a }),
    [chanB]: (b) => ({ b }),
  });

  t.deepEqual(ret, { b: "test" });
});

test("non-blocking select on buffered channel", async (t) => {
  const chanA = makeChan({
    bufferSize: 2,
  });
  const chanB = makeChan({
    bufferSize: 2,
  });

  // a select with a default case should be synchronous
  t.deepEqual(
    select({
      [chanA]: (a) => ({ a }),
      [chanB]: (b) => ({ b }),
      _: () => "nothing",
    }),
    "nothing"
  );

  // write to buffer
  await chanA.put("stuff");
  t.deepEqual(
    select({
      [chanA]: (a) => ({ a }),
      [chanB]: (b) => ({ b }),
      _: () => "nothing",
    }),
    { a: "stuff" }
  );

  // back to nothing
  t.deepEqual(
    select({
      [chanA]: (a) => ({ a }),
      [chanB]: (b) => ({ b }),
      _: () => "nothing",
    }),
    "nothing"
  );

  // now from b
  await chanB.put("stuff");
  t.deepEqual(
    select({
      [chanA]: (a) => ({ a }),
      [chanB]: (b) => ({ b }),
      _: () => "nothing",
    }),
    { b: "stuff" }
  );

  // back to nothing
  t.deepEqual(
    select({
      [chanA]: (a) => ({ a }),
      [chanB]: (b) => ({ b }),
      _: () => "nothing",
    }),
    "nothing"
  );

  // from both
  await chanA.put("stuff");
  await chanB.put("stuff");

  // read from a
  t.deepEqual(
    select({
      [chanA]: (a) => ({ a }),
      [chanB]: (b) => ({ b }),
      _: () => "nothing",
    }),
    { a: "stuff" }
  );

  // fail a, read b
  t.deepEqual(
    select({
      [chanA]: (a) => ({ a }),
      [chanB]: (b) => ({ b }),
      _: () => "nothing",
    }),
    { b: "stuff" }
  );

  // back to nothing
  t.deepEqual(
    select({
      [chanA]: (a) => ({ a }),
      [chanB]: (b) => ({ b }),
      _: () => "nothing",
    }),
    "nothing"
  );
});