the-client/test/TheClientTest.js

/**
 * Test for TheClient.
 * Runs with mocha.
 */
'use strict'

const {TheServer} = require('the-server')
const TheClient = require('../lib/TheClient')
const {TheError} = require('the-error')
const {ok, equal, deepEqual} = require('assert')
const aport = require('aport')
const fs = require('fs')
const asleep = require('asleep')

describe('the-client', () => {
  before(() => {
  })

  after(() => {
  })

  it('Do test', async function () {
    this.timeout(20 * 1000)
    ok(TheClient)

    const port = await aport()

    class FruitShopCtrl extends TheServer.Ctrl {

      buy (name, amount) {
        const {session, callbacks} = this
        const {total = 0} = session
        session.total = total + amount
        const result = {name, amount, total: session.total}
        asleep(10)
        callbacks.onBuy(amount, session.total)
        return result
      }

      doWrong () {
        throw new TheError('Something is wrong')
      }
    }

    const server = new TheServer({
      controllers: {
        fruitShop: FruitShopCtrl
      }
    })
    await server.listen(port)

    const onBuyData = []

    {
      const client01 = TheClient.for('c1', {port})
      const client02 = TheClient.for('c2', {port})

      ok(client01.cid)
      ok(client02.cid)

      const {fruitShop: fruitShop02} = await client02.useAll()
      const fruitShop01 = await client01.use('fruitShop')

      fruitShop01.setCallback({
        onBuy (...results) {
          onBuyData.push(results)
        }
      })

      {

        const controllers = await client01.useAll()
        deepEqual(Object.keys(controllers), ['fruitShop'])
        ok(controllers['fruitShop'])
      }

      deepEqual(
        await fruitShop01.buy('orange', 100),
        {name: 'orange', amount: 100, total: 100}
      )

      deepEqual(
        await fruitShop01.buy('orange', 400),
        {name: 'orange', amount: 400, total: 500}
      )

      deepEqual(
        await fruitShop02.buy('orange', 400),
        {name: 'orange', amount: 400, total: 400}
      )

      {
        const caught = await fruitShop01.doWrong().catch((e) => e)
        ok(caught)
      }

      await asleep(100)

      client01.pingPongAnd(() => console.log('pong!'), {
        interval: 10,
        retryMax: 3,
      })

      await asleep(100)

      const serverInfo = await client02.serverInfo()
      deepEqual(serverInfo.controllers, [
        {
          'methods': {
            'buy': {'desc': 'buy'},
            'doWrong': {'desc': 'doWrong'}
          },
          'name': 'fruitShop'
        }
      ])
      await client01.close()

      await asleep(10)

      await client02.close()

    }

    await server.close()

    await asleep(200)

    deepEqual(onBuyData, [[100, 100], [400, 500]])
  })

  it('Using stream api', async () => {
    const port = await aport()

    class CountdownStream extends TheServer.Stream {

      onOpen () {
        this.count = this.params.count
        void this.countdown()
      }

      async countdown () {
        while (this.count > 0) {
          await this.send({count: this.count})
          await asleep(1)
          this.count--
        }
        this.close()
      }
    }

    const server = new TheServer({
      streams: {
        countdown: CountdownStream
      }
    })
    await server.listen(port)

    const client01 = TheClient.for('c1', {port})

    {
      const stream = await client01.stream('countdown', {count: 100})
      const received = []
      stream.on('receive', (data) => received.push(data))
      await stream.wait()
      console.log(received)
    }

    await client01.close()
    await server.close()
    await asleep(100)
  })
})

/* global describe, before, after, it */