Add playback generator

src/common/chunks-to-body.ts

@@ -0,0 +1,44 @@
+type Headers = { [k: string]: string }
+
+const isBuffer = Buffer.isBuffer
+const isString = (a: any): a is string => typeof a === 'string'
+
+const isContentEncoded = (headers: Headers) => {
+  const encoding = headers['content-encoding']
+  return isString(encoding) && encoding !== ''
+}
+
+const isBinaryBuffer = (buffer: Buffer) => {
+  if (!isBuffer(buffer)) return false
+
+  const reconstructedBuffer = new Buffer(buffer.toString('utf8'), 'utf8')
+  if (buffer.length !== reconstructedBuffer.length) return true
+
+  for (var i = 0; i < buffer.length; ++i)
+    if (buffer[i] !== reconstructedBuffer[i])
+      return true
+
+  return false
+}
+
+const mergeBuffers = (chunks: Buffer[]) => {
+  if (chunks.length === 0) return new Buffer(0)
+  if (!isBuffer(chunks[0])) return new Buffer(chunks.join(''), 'utf8')
+  return Buffer.concat(chunks)
+}
+
+const processEncodedBuffers = (chunks: Buffer[]) => chunks.map(c => {
+  if (!isBuffer(c) && isString(c)) c = new Buffer(c)
+  return c.toString('hex')
+})
+
+export default (chunks: Buffer[], headers: Headers = {}) => {
+  if (isContentEncoded(headers)) return processEncodedBuffers(chunks)
+  const mergedBuffers = mergeBuffers(chunks)
+  if (isBinaryBuffer(mergedBuffers)) return mergedBuffers.toString('hex')
+
+  const stringified = mergedBuffers.toString('utf8')
+  if (stringified.length === 0) return {}
+  try { return JSON.parse(stringified) }
+  catch (errr) { return stringified }
+}

src/common/normalize-options.ts

@@ -3,17 +3,21 @@ import { Options } from '../interfaces'
 
 const fromString = (str: string): Options => {
   const { hostname, port, path } = url.parse(str)
-  return { hostname, method: 'GET', port: Number(port), path, __recording__: false }
-}
-
-const setProto = (options: any) => {
-  options.proto = options.proto || (options._https_ ? 'https' : 'http')
+  return {
+    hostname,
+    method: 'GET',
+    port: Number(port),
+    __recording__: false,
+    __https__: false,
+    path,
+  }
 }
 
 export default (raw: Options | string, protocol: string): Options => {
   const options = typeof raw === 'string' ? fromString(raw) : raw
+  options.__https__ = protocol === 'https'
   options.method = options.method || 'GET'
-  options.port = options.port || ((options.protocol === 'http') ? 80 : 443)
+  options.port = options.port || (options.__https__ ? 443 : 80)
 
   if (options.host && !options.hostname) {
     if (options.host.split(':').length === 2)
@@ -27,6 +31,5 @@ export default (raw: Options | string, protocol: string): Options => {
   options.hostname = options.hostname.toLowerCase()
   options.host = options.host.toLowerCase()
 
-  setProto(options)
   return options
 }

src/interfaces.d.ts

@@ -1,7 +1,7 @@
 import { RequestOptions, IncomingMessage, ClientRequest } from 'http'
 
 export type Request = ClientRequest
-export type Options = RequestOptions & { __recording__: boolean }
+export type Options = RequestOptions & { __recording__: boolean, __https__: boolean }
 export type Response = IncomingMessage
 export type Callback = (res: Response) => void
 export type RequestMaker = (options: Options, cb?: Callback) => Request

src/recorder/record.ts

@@ -1,14 +1,39 @@
 import * as I from '../interfaces'
 import * as Request from './request'
 import * as Response from './response'
+import chunksToBody from '../common/chunks-to-body'
+
+const getScope = ({ host, __https__, port }: I.Options) => {
+  let scope = `${__https__ ? 'https' : 'http'}://${host}`
+  const isDefaultPort = port.toString() === (__https__ ? '443' : '80')
+  const needPort = !host.includes(':') && port && isDefaultPort
+  return needPort ? `${scope}:${port}` : scope
+}
+
+const generatePlayback = (
+  req: I.Request,
+  res: I.Response,
+  options: I.Options,
+  requestBody: Buffer[],
+  responseBody: Buffer[]
+) => ({
+  scope: getScope(options),
+  path: options.path,
+  method: options.method || 'GET',
+  status: res.statusCode,
+  body: chunksToBody(requestBody),
+  response: chunksToBody(responseBody, res.headers),
+  rawHeaders: res.rawHeaders || res.headers
+})
 
 export default async (protocol: string, options: I.Options, req: I.Request, res: I.Response) => {
   const requestBody: Buffer[] = []
   const responseBody: Buffer[] = []
-  Request.onData(req, chunk => requestBody.push(chunk))
-  Response.onData(res, chunk => responseBody.push(chunk))
+  Request.onData(req, requestBody.push.bind(requestBody))
+  Response.onData(res, responseBody.push.bind(responseBody))
   await Response.waitEnd(res)
 
-  console.dir(Buffer.concat(requestBody).toString('utf8'))
-  console.dir(Buffer.concat(responseBody).toString('utf8'))
+  console.log(options.host)
+  const playback = generatePlayback(req, res, options, requestBody, responseBody)
+  console.dir(playback, {colors: true, depth: 5})
 }

src/test/flow.ts

@@ -5,8 +5,7 @@ import record from '../recorder'
 record()
 
 test('Flow', async t => {
-  const response = await requet('https://api.github.com/repos/octokit/octokit.rb', {
+  const response = await requet.get('http://api.github.com/repos/octokit/octokit.rb', {
     headers: { 'user-agent': 'ava-playback' }, json: true })
-  console.log(Object.keys(response))
   t.true(typeof response === 'object')
 })