npm install node-stream-test
creates test Readable
stream, simulating sync
/async
behaviors
(options: MakeReadableOptions) => (readableOptions: ReadableOptions) => (iterable: Iterable<any>) => Readable
type MakeReadableOptions = {
eager: boolean // lazy or eager stream behavior
log?: typeof console.log // provide debug logger or noop
delayMs?: number // simulate async stream behavior
errorAtStep?: number // emit 'error' event at certain step
continueOnError?: boolean // whether should stream continue on error or break
}
Lazy stream pushes one
chunk
of data on everyread
.
Eager stream pushes allchunks
in a synchronous loop onread
.
delayMs
is a delay betweenread
call and actualchunk
push.
This simulates asynchronous stream behavior.
If the stream iseager
, it will push allchunks
in a loop after first delay
import { readable } from 'node-stream-test'
// create test-readable stream
const testReadable = readable({
log: console.log, // output debug info to console
delayMs: 10, // delay 10ms
eager: false // eager or lazy stream
})({
objectMode: true // provide Node Readable configuration
})(
[1, 2, 3, 4, 5] // provide data to stream
)
// subscribe to test-readable
testReadable
.on('data', () => {})
.on('end', () => {})
creates test Writable
stream, simulating sync
/async
behaviors
(options: MakeWritableOptions) => (writableOptions: WritableOptions) => (sink: (chunk: any) => void) => Writable
type MakeWritableOptions = {
log: typeof console.log, // provide debug logger or noop
delayMs?: number // simulate async
errorAtStep?: number // emit 'error' event at certain step
}
delayMs
is a delay betweenwrite
call and passingchunk
to a sink.
This simulates long async writes.
import { writable } from 'node-stream-test'
// We have the following stream
declare var stream: ReadableStream
const testWritable = writable({
log: console.log, // output debug info to console
delayMs: 10 // delay 10ms
})({
objectMode: true // provide Node Writable configuration
})
// pipe the stream into test-writable
stream.pipe(
stream,
testWritable
).on('data', () => {})
.on('end', () => {})
writes chunks
to a stream
(options: ProducerOptions) => (iterable: Iterable<any>) => (stream: WritableStream) => () => void
type ProducerOptions = {
log: typeof console.log, // provide debug logger or noop
eager: boolean // eager or lazy producer
}
eager
producer writeschunks
in a synchronous loop untilhighWatermark
reached.
lazy
producer writes onechunk
ondrain
event.
import { producer } from 'node-stream-test'
// We have the following writable stream
declare var stream: WritableStream
// create a producer
const beginProduce = producer({
log: console.log, // output debug info to console
eager: true // eager producer
})(
[1, 2, 3, 4, 5], // data to write
0 // write all data
)(
stream // write to this stream
)
simple on('data')
consumer with logging
(options: DataConsumerOptions) => (sink: (chunk: any) => void) => (stream: ReadableStream) => () => void
type PushConsumerOptions = {
log: typeof console.log // provide debug logger or noop
}
import { pushConsumer } from 'node-stream-test'
// We have the following stream
declare var stream: ReadableStream
pushConsumer({
log: console.log // output debug info to console
})(
(chunk: string) => {} // your callback on every `data` event
)(
stream, // stream to consume
)
simple on('readable')
consumer with sync/async
behavior and logging
(options: ReadableConsumerOptions) => (sink: (chunk: any) => void) => (stream: ReadableStream) => () => void
type PullConsumerOptions = {
log: typeof console.log, // provide debug logger or noop
delayMs?: number, // simulate async
eager?: boolean, // eager or lazy behavior
readSize?: number // how much data to read on each 'readable' event
}
delayMs
is a time betweenreadable
event and actualread
call on stream.
eager
consumer callsread
in synchronous loop untilnull
returned.
Then waits for the nextreadable
.
lazy
consumer reads onechunk
, then waits.
import { pullConsumer } from 'node-stream-test'
// We have the following stream
declare var stream: ReadableStream
pullConsumer({
log: console.log, // print debug info to console
delayMs: 10, // delay 10ms
eager: false, // lazy behavior
readSize: undefined // read all available data
})(
(chunk: string) => {} // your callback on `read` call, after `readable` event
)(
stream, // stream to consume
)