Function assertTickerSurvives

packages/platform/node/test/RpcServer.test.ts:231–274

(
    setup: Effect.Effect<
      {
        readonly ticker: Stream.Stream<number, E>
        readonly failingCall: Effect.Effect<void>
      },
      never,
      R
    >,
    label: string
  )

  )

  const assertTickerSurvives = <E, R>(
    setup: Effect.Effect<
      {
        readonly ticker: Stream.Stream<number, E>
        readonly failingCall: Effect.Effect<void>
      },
      never,
      R
    >,
    label: string
  ) =>
    Effect.gen(function*() {
      const { failingCall, ticker } = yield* setup

      const received = yield* Ref.make<Array<number>>([])

      const tickerFiber = yield* ticker.pipe(
        Stream.runForEach((value) => Ref.update(received, (xs) => [...xs, value])),
        Effect.forkChild
      )

      yield* Effect.retry(
        Effect.flatMap(
          Ref.get(received),
          (xs) => xs.length >= 2 ? Effect.void : Effect.fail("not enough ticks yet")
        ),
        { schedule: Schedule.spaced("50 millis"), times: 200 }
      )

      const ticksBefore = (yield* Ref.get(received)).length
      assert.isAtLeast(ticksBefore, 2)

      yield* failingCall

      yield* Effect.sleep("300 millis")

      const ticksAfter = (yield* Ref.get(received)).length
      const tickerStatus = tickerFiber.pollUnsafe()

      yield* Fiber.interrupt(tickerFiber)

      assert.isUndefined(tickerStatus, `Ticker stream must still be running after ${label}`)
      assert.isAbove(ticksAfter, ticksBefore, `Ticker stream must keep emitting after ${label}`)
    })

  describe("unknown-tag isolation", () => {
    const Ghost = Rpc.make("Ghost", {