@juzi/wechaty-puppet-service 1.0.0

package/src/config.ts

@@ -0,0 +1,31 @@
+/// <reference path="./typings.d.ts" />
+
+import { log } from '@juzi/wechaty-puppet'
+
+import { packageJson } from './package-json.js'
+
+import * as rootEnvVars from './env-vars.js'
+import * as authEnvVars from './auth/env-vars.js'
+
+const VERSION = packageJson.version || '0.0.0'
+
+const envVars = {
+  ...rootEnvVars,
+  ...authEnvVars,
+}
+
+/**
+ * gRPC default options
+ */
+const GRPC_OPTIONS = {
+  // https://github.com/wechaty/wechaty-puppet-service/issues/86
+  // 'grpc.max_receive_message_length': 1024 * 1024 * 150,
+  // 'grpc.max_send_message_length': 1024 * 1024 * 150,
+}
+
+export {
+  envVars,
+  log,
+  GRPC_OPTIONS,
+  VERSION,
+}

package/src/deprecated/chunk-pb.spec.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import { test } from 'tstest'
+
+import { PassThrough } from 'stream'
+
+import { FileBox } from 'file-box'
+
+import {
+  puppet,
+}                                 from '@juzi/wechaty-grpc'
+
+import {
+  unpackFileBoxFromChunk,
+  packFileBoxToChunk,
+}                             from './file-box-chunk.js'
+import {
+  unpackFileBoxChunkFromPb,
+  packFileBoxChunkToPb,
+}                             from './chunk-pb.js'
+
+test('packFileBoxChunk()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const chunkStream = await packFileBoxToChunk(fileBox)
+  const pbStream    = await packFileBoxChunkToPb(puppet.MessageFileStreamResponse)(chunkStream)
+
+  let   name        = ''
+  let   buffer      = ''
+  pbStream.on('data', (data: puppet.MessageFileStreamResponse) => {
+    if (data.hasFileBoxChunk()) {
+      const fileBoxChunk = data.getFileBoxChunk()
+      if (fileBoxChunk!.hasData()) {
+        buffer += fileBoxChunk!.getData()
+      } else if (fileBoxChunk!.hasName()) {
+        name = fileBoxChunk!.getName()
+      }
+    }
+  })
+
+  await new Promise(resolve => chunkStream.on('end', resolve))
+  t.equal(name, FILE_BOX_NAME, 'should get file box name')
+  t.equal(buffer, FILE_BOX_DATA, 'should get file box data')
+
+})
+
+test('unpackFileBoxChunkFromPb()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const chunkStream = await packFileBoxToChunk(fileBox)
+  const request = new puppet.MessageSendFileStreamRequest()
+
+  const packedStream = new PassThrough({ objectMode: true })
+
+  chunkStream.on('data', (data: puppet.FileBoxChunk) => {
+    request.setFileBoxChunk(data)
+    packedStream.write(request)
+  }).on('end', () => {
+    packedStream.end()
+  })
+
+  const outputChunkStream = unpackFileBoxChunkFromPb(packedStream)
+  const outputFileBox = await unpackFileBoxFromChunk(outputChunkStream)
+
+  t.equal((await outputFileBox.toBuffer()).toString(), FILE_BOX_DATA, 'should get file box data')
+})
+
+test('packFileBoxChunk() <-> unpackFileBoxChunkFromPb()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const chunkStream = await packFileBoxToChunk(fileBox)
+  const packedStream = packFileBoxChunkToPb(puppet.MessageFileStreamResponse)(chunkStream)
+
+  const unpackedStream = unpackFileBoxChunkFromPb(packedStream)
+  const restoredBox = await unpackFileBoxFromChunk(unpackedStream)
+  t.equal(fileBox.name, restoredBox.name, 'should be same name')
+
+  const EXPECTED_BASE64 = await fileBox.toBase64()
+  const actualBase64 = await restoredBox.toBase64()
+
+  t.equal(EXPECTED_BASE64, actualBase64, 'should be same content')
+})
+
+test('packFileBoxChunk(): should not throw if no read on the stream', async t => {
+
+  t.plan(1)
+  const stream = await getTestChunkStream({})
+  let outStream
+  try {
+    outStream = packFileBoxChunkToPb(puppet.MessageFileStreamResponse)(stream)
+  } catch (e) {
+    t.ok((e as Error).message)
+    return
+  }
+  outStream.on('error', _ => { /* Do nothing */ })
+  t.pass()
+})
+
+test('packFileBoxChunk(): should emit error in the output stream', async t => {
+  const EXPECTED_MESSAGE = 'test emit error'
+
+  const stream = await getTestChunkStream({ errorMessage: EXPECTED_MESSAGE })
+  const outStream = packFileBoxChunkToPb(puppet.MessageFileStreamResponse)(stream)
+
+  const error = await new Promise<Error>(resolve => outStream.on('error', resolve))
+  // await new Promise(resolve => outStream.on('end', resolve))
+  t.equal(error.message, EXPECTED_MESSAGE, 'should emit error message')
+})
+
+test('unpackFileBoxChunkFromPb(): should not throw if no read on the stream', async t => {
+
+  t.plan(1)
+  const stream = await getTestPackedStream({})
+  let outStream
+  try {
+    outStream = unpackFileBoxChunkFromPb(stream)
+    t.pass('should no rejection')
+  } catch (e) {
+    t.fail((e as Error).message)
+    return
+  }
+  outStream.on('error', _ => { /* Do nothing */ })
+})
+
+test('unpackFileBoxChunkFromPb(): should emit error in the output stream', async t => {
+
+  const errorMessage = 'test emit error'
+  const stream = await getTestPackedStream({ errorMessage })
+
+  const outStream = packFileBoxChunkToPb(puppet.MessageFileStreamResponse)(stream)
+
+  try {
+    await new Promise((resolve, reject) => {
+      outStream.on('error', reject)
+      outStream.on('end', resolve)
+    })
+    t.fail('should reject the promise')
+  } catch (e) {
+    t.equal((e as Error).message, errorMessage, 'should get the expected rejection error message')
+  }
+})
+
+async function getTestChunkStream (options: {
+  errorMessage?: string,
+}) {
+  const { errorMessage } = options
+
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const chunkStream = await packFileBoxToChunk(fileBox)
+  setImmediate(() => {
+    chunkStream.emit('error', new Error(errorMessage))
+  })
+
+  return chunkStream
+}
+
+async function getTestPackedStream (options: {
+  errorMessage?: string,
+}) {
+  const { errorMessage } = options
+
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const chunkStream = await packFileBoxToChunk(fileBox)
+  const packedStream = new PassThrough({ objectMode: true })
+  chunkStream.on('data', d => {
+    const packedChunk = new puppet.MessageFileStreamResponse()
+    packedChunk.setFileBoxChunk(d)
+    packedStream.write(packedChunk)
+  }).on('error', e => {
+    packedStream.emit('error', e)
+  })
+
+  setImmediate(() => {
+    chunkStream.emit('error', new Error(errorMessage))
+  })
+
+  return packedStream
+}

package/src/deprecated/chunk-pb.ts

@@ -0,0 +1,75 @@
+import type { puppet } from '@juzi/wechaty-grpc'
+import { Readable, Transform } from 'stronger-typed-streams'
+import { PassThrough } from 'stream'
+
+import type { FileBoxPb } from './file-box-pb.type.js'
+
+/**
+ * Wrap FileBoxChunk
+ * @deprecated Will be removed after Dec 31, 2022
+ */
+const encoder = <T extends FileBoxPb>(
+  PbConstructor: { new(): T },
+) => new Transform<puppet.FileBoxChunk, T>({
+  objectMode: true,
+  transform: (chunk: puppet.FileBoxChunk, _: any, callback: (error: Error | null, data: T) => void) => {
+    const message = new PbConstructor()
+    message.setFileBoxChunk(chunk)
+    callback(null, message)
+  },
+})
+
+/**
+ * @deprecated Will be removed after Dec 31, 2022
+ */
+function packFileBoxChunkToPb<T extends FileBoxPb> (
+  PbConstructor: { new(): T },
+) {
+  return (stream: Readable<puppet.FileBoxChunk>): Readable<T> => {
+    const outStream     = new PassThrough({ objectMode: true })
+    const encodedStream = stream.pipe(encoder(PbConstructor))
+
+    stream.on('error',        e => outStream.emit('error', e))
+    encodedStream.on('error', e => outStream.emit('error', e))
+
+    encodedStream.pipe(outStream)
+    return outStream
+  }
+}
+
+/**
+ * Unwrap FileBoxChunk
+ * @deprecated Will be removed after Dec 31, 2022
+ */
+const decoder = <T extends FileBoxPb>() => new Transform<T, puppet.FileBoxChunk>({
+  objectMode: true,
+  transform: (chunk: T, _: any, callback: (error: Error | null, data?: puppet.FileBoxChunk) => void) => {
+    const fileBoxChunk = chunk.getFileBoxChunk()
+    if (!fileBoxChunk) {
+      callback(new Error('No FileBoxChunk'))
+    } else {
+      callback(null, fileBoxChunk)
+    }
+  },
+})
+
+/**
+ * @deprecated Will be removed after Dec 31, 2022
+ */
+function unpackFileBoxChunkFromPb<T extends FileBoxPb> (
+  stream: Readable<T>,
+): Readable<puppet.FileBoxChunk> {
+  const outStream     = new PassThrough({ objectMode: true })
+  const decodedStream = stream.pipe(decoder())
+
+  stream.on('error',        e => outStream.emit('error', e))
+  decodedStream.on('error', e => outStream.emit('error', e))
+
+  decodedStream.pipe(outStream)
+  return outStream
+}
+
+export {
+  packFileBoxChunkToPb,
+  unpackFileBoxChunkFromPb,
+}

package/src/deprecated/conversation-id-file-box.spec.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+import {
+  puppet,
+}                                       from '@juzi/wechaty-grpc'
+
+import { test }         from 'tstest'
+import { PassThrough }  from 'stream'
+import { FileBox }      from 'file-box'
+
+import { nextData }     from './next-data.js'
+import {
+  packConversationIdFileBoxToPb,
+  unpackConversationIdFileBoxArgsFromPb,
+}                                         from './conversation-id-file-box.js'
+
+test('unpackConversationIdFileBoxArgsFromPb()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+  const CONVERSATION_ID = 'conversation_id'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const stream = new PassThrough({ objectMode: true })
+
+  const req1 = new puppet.MessageSendFileStreamRequest()
+  req1.setConversationId(CONVERSATION_ID)
+  stream.write(req1)
+
+  const req2 = new puppet.MessageSendFileStreamRequest()
+  const chunk1 = new puppet.FileBoxChunk()
+  chunk1.setName(fileBox.name)
+  req2.setFileBoxChunk(chunk1)
+  stream.write(req2)
+
+  const fileBoxStream = await fileBox.toStream()
+  fileBoxStream.on('data', chunk => {
+    const fileBoxChunk = new puppet.FileBoxChunk()
+    fileBoxChunk.setData(chunk)
+    const req3 = new puppet.MessageSendFileStreamRequest()
+    req3.setFileBoxChunk(fileBoxChunk)
+    stream.write(req3)
+  })
+  fileBoxStream.on('end', () => stream.end())
+
+  const args = await unpackConversationIdFileBoxArgsFromPb(stream)
+  const data = (await args.fileBox.toBuffer()).toString()
+
+  t.equal(args.conversationId, CONVERSATION_ID, 'should get conversation id')
+  t.equal(args.fileBox.name, FILE_BOX_NAME, 'should get file box name')
+  t.equal(data, FILE_BOX_DATA, 'should get file box data')
+})
+
+test('packConversationIdFileBoxToPb()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+  const CONVERSATION_ID = 'conv_id'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const stream = await packConversationIdFileBoxToPb(puppet.MessageSendFileStreamRequest)(
+    CONVERSATION_ID,
+    fileBox,
+  )
+
+  const data1 = await nextData(stream)
+  t.equal(data1.getConversationId(), CONVERSATION_ID, 'match conversation id')
+
+  const data2 = await nextData(stream)
+  t.ok(data2.hasFileBoxChunk(), 'has file box chunk')
+  t.ok(data2.getFileBoxChunk()!.hasName(), 'has file box name')
+  t.equal(data2.getFileBoxChunk()!.getName(), FILE_BOX_NAME, 'match file box name')
+
+  let data = ''
+  stream.on('data', (chunk: puppet.MessageSendFileStreamRequest) => {
+    if (!chunk.hasFileBoxChunk()) {
+      throw new Error('no file box chunk')
+    }
+    if (!chunk.getFileBoxChunk()!.hasData()) {
+      throw new Error('no file box chunk data')
+    }
+    data += chunk.getFileBoxChunk()!.getData()
+  })
+
+  await new Promise(resolve => stream.on('end', resolve))
+
+  t.equal(data.toString(), FILE_BOX_DATA, 'should get file box data')
+})
+
+test('unpackConversationIdFileBoxArgsFromPb() <-> packConversationIdFileBoxToPb()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+  const CONVERSATION_ID = 'conv_id'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const stream = await packConversationIdFileBoxToPb(puppet.MessageSendFileStreamRequest)(CONVERSATION_ID, fileBox)
+  const args = await unpackConversationIdFileBoxArgsFromPb(stream)
+
+  t.equal(args.conversationId, CONVERSATION_ID, 'should match conversation id')
+  t.equal(args.fileBox.name, FILE_BOX_NAME, 'should be same name')
+  t.equal((await args.fileBox.toBuffer()).toString(), FILE_BOX_DATA, 'should be same content')
+})

package/src/deprecated/conversation-id-file-box.ts

@@ -0,0 +1,72 @@
+import type {
+  FileBoxInterface,
+}                               from 'file-box'
+import { PassThrough }          from 'stream'
+import type { Readable }             from 'stronger-typed-streams'
+
+import { nextData }                 from './next-data.js'
+import {
+  packFileBoxToPb,
+  unpackFileBoxFromPb,
+}                                  from './file-box-pb.js'
+import type { ConversationIdFileBoxPb } from './file-box-pb.type.js'
+
+interface ConversationIdFileBoxArgs {
+  conversationId: string,
+  fileBox: FileBoxInterface,
+}
+
+/**
+ * MessageSendFileStreamRequest to Args
+ * @deprecated Will be removed after Dec 31, 2022
+ */
+async function unpackConversationIdFileBoxArgsFromPb (
+  stream: Readable<ConversationIdFileBoxPb>,
+): Promise<ConversationIdFileBoxArgs> {
+  const chunk = await nextData(stream)
+  if (!chunk.hasConversationId()) {
+    throw new Error('no conversation id')
+  }
+  const conversationId = chunk.getConversationId()
+
+  // unpackFileBoxFromChunk(unpackFileBoxChunkFromPb(stream))
+  const fileBox = await unpackFileBoxFromPb(stream)
+
+  return {
+    conversationId,
+    fileBox,
+  }
+}
+
+/**
+ * Args to MessageSendFileStreamRequest
+ * @deprecated Will be removed after Dec 31, 2022
+ */
+function packConversationIdFileBoxToPb<T extends ConversationIdFileBoxPb> (
+  PbConstructor: { new(): T },
+) {
+  return async (
+    conversationId: string,
+    fileBox:        FileBoxInterface,
+  ): Promise<
+    Readable<T>
+  > => {
+    const stream = new PassThrough({ objectMode: true })
+
+    const first = new PbConstructor()
+    first.setConversationId(conversationId)
+    stream.write(first)
+
+    // const fileBoxChunkStream = await packFileBoxToChunk(fileBox)
+    // packFileBoxChunkToPb(MessageSendFileStreamRequest)(fileBoxChunkStream)
+    const pbStream = await packFileBoxToPb(PbConstructor)(fileBox)
+    pbStream.pipe(stream)
+
+    return stream
+  }
+}
+
+export {
+  unpackConversationIdFileBoxArgsFromPb,
+  packConversationIdFileBoxToPb,
+}

package/src/deprecated/file-box-chunk.spec.ts

@@ -0,0 +1,184 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+import { test } from 'tstest'
+
+import { PassThrough }  from 'stream'
+import type { Duplex }       from 'stronger-typed-streams'
+import { FileBox }      from 'file-box'
+
+import {
+  puppet,
+}                 from '@juzi/wechaty-grpc'
+
+import {
+  unpackFileBoxFromChunk,
+  packFileBoxToChunk,
+}                         from './file-box-chunk.js'
+import { nextData }       from './next-data.js'
+
+test('unpackFileBoxFromChunk()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const stream = await getFileBoxStreamStub(FILE_BOX_DATA, FILE_BOX_NAME)
+
+  const decodedFileBox = await unpackFileBoxFromChunk(stream)
+  const data = (await decodedFileBox.toBuffer()).toString()
+
+  t.equal(decodedFileBox.name, FILE_BOX_NAME, 'should get file box name')
+  t.equal(data, FILE_BOX_DATA, 'should get file box data')
+
+})
+
+test('packFileBoxToChunk()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const stream = await packFileBoxToChunk(fileBox)
+
+  const fileBoxChunk = await nextData(stream)
+  t.ok(fileBoxChunk.hasName(), 'has name')
+
+  const fileName = fileBoxChunk.getName()
+  t.equal(fileName, FILE_BOX_NAME, 'should get name')
+
+  let data = ''
+  stream.on('data', (chunk: puppet.FileBoxChunk) => {
+    if (!chunk.hasData()) {
+      throw new Error('no data')
+    }
+    data += chunk.getData()
+  })
+
+  await new Promise(resolve => stream.on('end', resolve))
+
+  t.equal(data, FILE_BOX_DATA, 'should get file box data')
+})
+
+test('packFileBoxToChunk() <-> unpackFileBoxFromChunk()', async t => {
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(FILE_BOX_DATA),
+    FILE_BOX_NAME,
+  )
+
+  const stream = await packFileBoxToChunk(fileBox)
+  const restoredBox = await unpackFileBoxFromChunk(stream)
+
+  t.equal(fileBox.name, restoredBox.name, 'should be same name')
+  t.equal(await fileBox.toBase64(), await restoredBox.toBase64(), 'should be same content')
+})
+
+test('should handle no name error in catch', async t => {
+  t.plan(1)
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const stream = await getFileBoxStreamStub(FILE_BOX_DATA, FILE_BOX_NAME, true)
+
+  try {
+    await unpackFileBoxFromChunk(stream)
+  } catch (e) {
+    t.equal((e as Error).message, 'no name')
+  }
+})
+
+test('should handle first error catch', async t => {
+  t.plan(1)
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const stream = await getFileBoxStreamStub(FILE_BOX_DATA, FILE_BOX_NAME, false, true)
+
+  try {
+    await unpackFileBoxFromChunk(stream)
+  } catch (e) {
+    t.equal((e as Error).message, 'first exception')
+  }
+})
+
+test('should handle middle error in further ops', async t => {
+  t.plan(1)
+  const FILE_BOX_DATA = 'test'
+  const FILE_BOX_NAME = 'test.dat'
+
+  const stream = await getFileBoxStreamStub(FILE_BOX_DATA, FILE_BOX_NAME, false, false, true)
+
+  const fileBox = await unpackFileBoxFromChunk(stream)
+  try {
+    await fileBox.toBuffer()
+  } catch (e) {
+    t.equal((e as Error).message, 'middle exception')
+  }
+})
+
+async function getFileBoxStreamStub (
+  data: string,
+  name: string,
+  noname = false,
+  firstException = false,
+  middleException = false,
+) {
+  const fileBox = FileBox.fromBuffer(
+    Buffer.from(data),
+    name,
+  )
+
+  const stream: Duplex<puppet.FileBoxChunk, puppet.FileBoxChunk> = new PassThrough({ objectMode: true })
+
+  if (firstException) {
+    stream.pause()
+    setImmediate(() => {
+      stream.emit('error', new Error('first exception'))
+      stream.resume()
+    })
+  } else {
+    const chunk1 = new puppet.FileBoxChunk()
+    if (!noname) {
+      chunk1.setName(fileBox.name)
+    }
+    setTimeout(() => stream.write(chunk1), 10)
+  }
+
+  if (middleException) {
+    setTimeout(() => {
+      stream.emit('error', new Error('middle exception'))
+    }, 100)
+  }
+
+  const fileBoxStream = await fileBox.toStream()
+  fileBoxStream.on('data', chunk => {
+    const fileBoxChunk = new puppet.FileBoxChunk()
+    fileBoxChunk.setData(chunk)
+    setTimeout(() => stream.write(fileBoxChunk), 200)
+  })
+  fileBoxStream.on('end', () => setTimeout(() => stream.end(), 250))
+
+  return stream
+}