gochan/test/index.js

'use strict'

const assert = require('@nodeguy/assert')
const Channel = require('../lib')
const stream = require('stream')

const assertRejects = async (callback, reason) => {
  try {
    await callback()
  } catch (exception) {
    if (reason) {
      assert.deepEqual(exception, reason)
    }

    return
  }

  assert.fail(null, reason, `Missing expected rejection.`)
}

const toArray = async (channel) => {
  const array = []

  await channel.forEach((item) => {
    array.push(item)
  })

  return array
}

describe(`Channel`, function () {
  it(`allows the use of new`, function () {
    return new Channel()
  })

  it(`is frozen`, function () {
    assert.throws(() => {
      Channel.frozen = false
    })
  })

  it(`creates a frozen object`, function () {
    assert.throws(() => {
      Channel().frozen = false
    })
  })

  it(`creates a buffered channel`, async function () {
    const channel = Channel(2)

    ;(async () => {
      assert.equal(await channel.shift(), 0)
    })()

    await channel.push(0)
    await channel.push(1)
    await channel.push(2)
  })

  describe(`from`, function () {
    it(`iterable`, async function () {
      assert.deepEqual(await toArray(Channel.from([0, 1, 2])), [0, 1, 2])
    })

    it(`Node.js's stream.readOnly`, async function () {
      const readOnly = stream.PassThrough({objectMode: true})
      readOnly.write(0)
      readOnly.write(1)
      readOnly.end(2)
      assert.deepEqual(await toArray(Channel.from(readOnly)), [0, 1, 2])
    })
  })

  it(`isChannel`, function () {
    assert(Channel.isChannel(Channel.of(0, 1, 2)))
    assert(!Channel.isChannel(Array.of(0, 1, 2)))
  })

  it(`of`, async function () {
    assert.deepEqual(await toArray(Channel.of(0, 1, 2)), [0, 1, 2])
  })

  describe(`select`, function () {
    it(`miscellaneous`, async function () {
      const a = Channel()
      const b = Channel()

      ;(async () => {
        await b.push(0)
        await a.push(1)
        await a.shift()
      })()

      assert.equal(await Channel.select(a.shift(), b.shift()), b)
      assert.equal(b.value, 0)
      assert.equal(await a.shift(), 1)
      assert.equal(await Channel.select(a.push(0), b.shift()), a)
    })
  })

  it(`allows for non-blocking selects`, async function () {
    const a = Channel()
    const b = Channel()
    const nonBlocking = Channel()
    nonBlocking.close()

    switch (await Channel.select(a.shift(), b.push(0), nonBlocking.shift())) {
      case a:
        assert(false)
        break

      case b:
        assert(false)
        break

      default:
        assert(true)
        break
    }
  })

  it(`cancel`, async function () {
    const channel = Channel()
    Channel.select(channel.push(`cancelled`)).cancel()
    const closed = Channel.of()
    assert.equal(await Channel.select(channel.shift(), closed.shift()), closed)
  })
})

describe(`functional interface`, async function () {
  describe(`map`, function () {
    it(`full application`, async function () {
      assert.deepEqual(
        await toArray(Channel.map(
          (value) => value.toUpperCase(),
          Channel.of(`a`, `b`, `c`)
        )),
        [`A`, `B`, `C`]
      )
    })

    it(`partial application`, async function () {
      assert.deepEqual(
        await toArray(Channel.map((value) =>
          value.toUpperCase())(Channel.of(`a`, `b`, `c`))
        ),
        [`A`, `B`, `C`]
      )
    })
  })

  describe(`slice`, function () {
    it(`full application`, async function () {
      assert.deepEqual(
        await toArray(Channel.slice(1, 4, Channel.of(0, 1, 2, 3, 4))),
        [1, 2, 3]
      )
    })

    it(`partial application`, async function () {
      assert.deepEqual(
        await toArray(Channel.slice(1, 4)(Channel.of(0, 1, 2, 3, 4))),
        [1, 2, 3]
      )
    })
  })
})

describe(`Channel object`, function () {
  describe(`close`, function () {
    it(`can't close an already closed channel`, function () {
      const channel = Channel()
      channel.close()

      return assertRejects(async () => {
        await channel.close()
      }, new Error(`Can't close an already-closed channel.`))
    })

    it(`can't push to a closed channel`, async function () {
      const channel = Channel()
      channel.close()

      return assertRejects(async () => {
        await channel.push(0)
      }, new Error(`Can't push to closed channel.`))
    })

    it(`returns 'undefined' immediately from shift`, async function () {
      const channel = Channel()
      channel.close()
      assert.strictEqual(await channel.shift(), undefined)
    })
  })

  it(`every`, async function () {
    const even = (number) => number % 2 === 0
    assert(!await Channel.of(0, 1, 2).every(even))
    assert(await Channel.of(0, 2, 4).every(even))
  })

  it(`filter`, async function () {
    assert.deepEqual(
      await toArray(Channel.of(0, 1, 2, 3, 4, 5)
        .filter((value) => value % 2 !== 0)
      ),
      [1, 3, 5]
    )
  })

  it(`forEach`, async function () {
    const output = Channel()

    ;(async () => {
      await Channel.of(0, 1, 2).forEach(output.push)
      output.close()
    })()

    assert.deepEqual(await toArray(output), [0, 1, 2])
  })

  it(`join`, async function () {
    assert.equal(await Channel.of(`a`, `b`, `c`).join(), `a,b,c`)
  })

  it(`map`, async function () {
    assert.deepEqual(
      await toArray(Channel.of(`a`, `b`, `c`)
        .map((value) => value.toUpperCase())
      ),
      [`A`, `B`, `C`]
    )
  })

  describe(`push`, function () {
    it(`with shift`, async function () {
      const channel = Channel()

      ;(async () => {
        await channel.push(0)
      })()

      assert.equal(await channel.shift(), 0)
    })

    describe(`undefined`, function () {
      it(`outside select`, function () {
        const channel = Channel()

        return assertRejects(
          async () => {
            await channel.push(undefined)
          },
          new TypeError(`Can't push 'undefined' to channel, use close instead.`)
        )
      })

      it(`inside select`, function () {
        const channel = Channel()

        return assertRejects(async () => {
          await Channel.select(channel.push(undefined))
        }, new TypeError(
          `Can't push 'undefined' to channel, use close instead.`
        ))
      })
    })

    it(`disallows multiple values`, function () {
      const channel = Channel()

      return assertRejects(async () => {
        await channel.push(0, 1, 2)
      }, new Error(`Can't push more than one value at a time.`))
    })

    it(`returns a frozen promise`, function () {
      assert.throws(() => {
        Channel().push(0).frozen = false
      })
    })
  })

  it(`readOnly`, async function () {
    const channel = Channel()
    const readOnly = channel.readOnly()

    assert.throws(() => {
      readOnly.close()
    })

    assert.throws(() => {
      readOnly.push(0)
    })

    assert.throws(() => {
      readOnly.writeOnly()
    })

    ;(async () => {
      await channel.push(1)
    })()

    assert.equal(readOnly.readOnly(), readOnly)
    assert.equal(await readOnly.shift(), 1)
    assert.equal(readOnly.value, 1)

    assert.throws(() => {
      readOnly.frozen = false
    })
  })

  describe(`reduce`, function () {
    it(`callbackfn only`, async function () {
      assert.equal(await Channel.of(0, 1, 2)
        .reduce(Math.max),
        2
      )
    })

    it(`initialValue`, async function () {
      assert.equal(await Channel.of(0, 1, 2)
        .reduce(Math.max, 10),
        10
      )
    })

    it(`no values without initialValue`, function () {
      return assertRejects(
        async () => {
          await Channel.of().reduce(Math.max)
        },
        new TypeError(`No values in channel and initialValue wasn't provided.`)
      )
    })
  })

  describe(`shift`, function () {
    it(`with push`, async function () {
      const channel = Channel()

      ;(async () => {
        await channel.push(0)
      })()

      assert.equal(await channel.shift(), 0)
    })

    it(`returns a frozen promise`, function () {
      assert.throws(() => {
        Channel().shift().frozen = false
      })
    })
  })

  describe(`slice`, function () {
    it(`start`, async function () {
      assert.deepEqual(await toArray(Channel.of(0, 1, 2).slice(1)), [1, 2])
    })

    it(`end`, async function () {
      assert.deepEqual(
        await toArray(Channel.of(0, 1, 2, 3, 4).slice(1, 4)),
        [1, 2, 3]
      )
    })
  })

  it(`value`, async function () {
    const channel = Channel()

    ;(async () => {
      await channel.push(0)
    })()

    await channel.shift()
    assert.equal(channel.value, 0)

    assert.throws(() => {
      channel.value = 1
    })

    channel.close()
    await channel.shift()
    assert.equal(channel.value, undefined)
  })

  describe(`writeOnly`, function () {
    it(`provides only write methods`, async function () {
      const channel = Channel()
      const writeOnly = channel.writeOnly()

      assert.throws(() => {
        writeOnly.readOnly()
      })

      assert.throws(() => {
        writeOnly.shift()
      })

      assert.equal(writeOnly.value, undefined)

      ;(async () => {
        await channel.shift()
      })()

      await writeOnly.push(0)
      writeOnly.close()

      assert.throws(() => {
        writeOnly.frozen = false
      })
    })
  })
})