console-web-node 0.0.12 → 0.1.0

package/README.md

@@ -1 +1,41 @@
-# console-web-node
+# console-web-node
+
+Guarda em memória as últimas linhas escritas no console (stdout/stderr) de um servidor Node com Express (ou NestJS sobre Express), e permite acompanhá-las de outra máquina: primeiro a janela guardada, depois as linhas novas em tempo real.
+
+## Servidor
+
+```js
+import consoleWebNode from 'console-web-node'
+import moment from 'moment'
+
+consoleWebNode({ express: app, moment })
+
+// NestJS: o logger já coloca data e hora
+consoleWebNode({ express: app.getHttpAdapter().getInstance(), maxLines: 100000 })
+```
+
+| opção | padrão | |
+|---|---|---|
+| `express` | — | app ou router express onde é registrada a rota dos logs |
+| `moment` | — | instância do moment para colocar data e hora nas linhas (sem ela as linhas ficam como foram escritas, para loggers que já colocam data e hora) |
+| `logsPath` | `/api/x/logs` | caminho da rota (relativo ao `express` informado) |
+| `maxLines` | `10000` | quantidade de linhas guardadas em memória |
+| `consoleTimestamp` | `true` | escreve também no console as linhas com data e hora |
+
+## Acompanhar os logs
+
+```sh
+export CONSOLE_WEB_NODE_KEY=<chave>
+npx console-web-node meusistema.com.br                 # https://meusistema.com.br/api/x/logs
+npx console-web-node https://meusistema.com.br/x/logs  # outro caminho
+```
+
+Rodando na pasta do projeto que usa a biblioteca, o `npx` usa a versão instalada nele (a mesma do servidor).
+
+## Chave de acesso
+
+```sh
+npx console-web-node --nova-chave
+```
+
+Gera uma chave aleatória (para a variável `CONSOLE_WEB_NODE_KEY`) e o hash dela, que vai em `KEY_HASH` em `src/auth.js`. Sem hash configurado nenhuma chave é aceita.

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "console-web-node",
-  "version": "0.0.12",
-  "description": "",
+  "version": "0.1.0",
+  "description": "Guarda em memória as últimas linhas do console de um servidor Node/Express e permite acompanhá-las de outra máquina (npx console-web-node <servidor>)",
   "main": "src/index.js",
   "type": "module",
+  "bin": {
+    "console-web-node": "src/client.js"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.js"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
   "scripts": {
     "start": "nodemon",
     "test:watch": "nodemon -x mocha -p 'src/**/*.test.js'",
@@ -21,10 +31,7 @@
   "homepage": "https://github.com/LeonardoRomeiro/console-web-node#readme",
   "devDependencies": {
     "chai": "^4.2.0",
-    "mocha": "^8.1.1",
-    "nodemon": "^2.0.4"
-  },
-  "dependencies": {
-    "minio": "^7.0.16"
+    "mocha": "^10.8.2",
+    "nodemon": "^3.1.14"
   }
 }

package/src/auth.js

@@ -0,0 +1,21 @@
+import crypto from 'crypto'
+
+// sha256 (base64) da chave de acesso aos logs, gerado com `npx console-web-node --nova-chave`
+// a chave é aleatória (256 bits): mesmo com o hash público não dá para descobri-la por força bruta
+// vazio: nenhuma chave é aceita
+export const KEY_HASH = 'PgYhxkg8Kk8BXArYKM8a6Y/ME7/cYn3COpBoAf9lm58='
+
+const sha256 = (value) => crypto.createHash('sha256').update(value).digest()
+
+// confere o cabeçalho Authorization (Bearer <chave>) com o hash da chave
+export function isAuthorized(authorization, keyHash = KEY_HASH) {
+  const match = /^Bearer (\S+)$/.exec(authorization || '')
+  const expected = Buffer.from(keyHash, 'base64')
+  if (!match || expected.length !== 32) return false
+  return crypto.timingSafeEqual(sha256(match[1]), expected)
+}
+
+export function newKey() {
+  const key = crypto.randomBytes(32).toString('hex')
+  return { key, hash: sha256(key).toString('base64') }
+}

package/src/client.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// acompanha os logs de um servidor com console-web-node: mostra a janela de linhas guardada e segue as novas
+// uso: npx console-web-node <servidor ou url> (chave na variável de ambiente CONSOLE_WEB_NODE_KEY)
+//      npx console-web-node --nova-chave
+import http from 'http'
+import https from 'https'
+import { newKey } from './auth.js'
+
+const KEY_ENV = 'CONSOLE_WEB_NODE_KEY'
+const RETRY_MS = 5000
+const RESPONSE_TIMEOUT_MS = 60000 // o servidor responde em até 30s mesmo sem linhas novas
+
+const [target] = process.argv.slice(2)
+
+if (target === '--nova-chave') {
+  const { key, hash } = newKey()
+  console.log(`Chave (guarde na variável de ambiente ${KEY_ENV} de quem vai acompanhar os logs):\n  ${key}\n`)
+  console.log(`Hash (substitua KEY_HASH em src/auth.js e publique uma nova versão):\n  ${hash}`)
+} else if (!target || target.startsWith('-')) {
+  console.error('uso: console-web-node <servidor ou url>   (ex.: meusistema.com.br, https://meusistema.com.br/api/x/logs)')
+  console.error('     console-web-node --nova-chave')
+  process.exitCode = 1
+} else if (!process.env[KEY_ENV]) {
+  console.error(`informe a chave de acesso aos logs na variável de ambiente ${KEY_ENV}`)
+  process.exitCode = 1
+} else {
+  const url = new URL(/^https?:\/\//.test(target) ? target : `https://${target}`)
+  if (url.pathname === '/') url.pathname = '/api/x/logs'
+  follow(url, process.env[KEY_ENV])
+}
+
+function follow(url, key, cursor = '') {
+  const started = Date.now()
+  let received = 0
+  let finished = false // erros da requisição e da resposta podem chegar juntos: segue uma vez só
+  if (cursor) url.searchParams.set('cursor', cursor)
+  const continueAfter = (wait, nextCursor) => {
+    if (finished) return
+    finished = true
+    setTimeout(() => follow(url, key, nextCursor), wait)
+  }
+  const retry = (error) => {
+    const reason = error.message || error.code || String(error) // falha de conexão pode vir só com o código (ex.: ECONNREFUSED)
+    if (!finished) console.error(`\n[console-web-node] ${reason}, tentando novamente em ${RETRY_MS / 1000}s...`)
+    continueAfter(RETRY_MS, cursor)
+  }
+
+  const request = (url.protocol === 'http:' ? http : https).get(url, { headers: { Authorization: `Bearer ${key}` } }, (res) => {
+    if (res.statusCode === 401) {
+      console.error(`[console-web-node] chave recusada pelo servidor, confira a variável de ambiente ${KEY_ENV}`)
+      process.exit(1)
+    }
+    const next = res.headers['x-cursor']
+    if (res.statusCode !== 200 || !next) {
+      res.resume()
+      return retry(new Error(`resposta inesperada do servidor (HTTP ${res.statusCode})`))
+    }
+    if (cursor && next.split('.')[0] !== cursor.split('.')[0]) console.log('\n[console-web-node] servidor reiniciado, logs desde o início:\n')
+
+    res.setEncoding('utf8')
+    res.on('data', (data) => {
+      received += data.length
+      process.stdout.write(data)
+    })
+    res.on('error', retry)
+    res.on('end', () => {
+      // resposta vazia imediata não deveria acontecer: espera um pouco para não ficar em loop
+      continueAfter(!received && Date.now() - started < 1000 ? 1000 : 0, next)
+    })
+  })
+  request.setTimeout(RESPONSE_TIMEOUT_MS, () => request.destroy(new Error('sem resposta do servidor')))
+  request.on('error', retry)
+}

package/src/index.js

@@ -1,165 +1,39 @@
-import { CircularBuffer } from './utils/circular-buffer.js'
-import minio from 'minio'
-import crypto from 'crypto'
-import eventEmitter from 'events'
-
-const LOGS_BUCKET = 'logs'
-const READ_TIMEOUT = 30000
-const LISTNER_TIMEOUT = 60000
-const BROADCAST_TOKEN = 'broadcast'
-const events = new eventEmitter()
-
-export default async function ConsoleWebNode({ consoleTimestamp = true, maxLines = 10000, express = null, name = 'logs', moment, logsPath = '/api/x/logs' }) {
-	const circularBuffer = CircularBuffer(maxLines)
-
-	let writeToFile = () => {}
-
-	if (process.env.MINIO_URL) {
-		const minioClient = new minio.Client({
-			endPoint: process.env.MINIO_URL,
-			accessKey: process.env.MINIO_ACCESS_KEY,
-			secretKey: process.env.MINIO_SECRET_KEY,
-			useSSL: true
-		})
-
-		!await minioClient.bucketExists(LOGS_BUCKET) && await minioClient.makeBucket(LOGS_BUCKET)
-
-		await minioClient.getObject(LOGS_BUCKET, name)
-    .then((stream) => new Promise((resolve) => {
-			const data = []
-			stream.on('data', data.push.bind(data))
-			stream.on('end', resolve.bind(null, data))
-		}))
-    .then((file) => Buffer.concat(file).toString().split('\n').forEach(line => circularBuffer.push(line + '\n')))
-		.catch(() => { })
-		
-		writeToFile = () => {
-			writeToFile._timeout && clearTimeout(writeToFile._timeout)
-			writeToFile._timeout = setTimeout(() => minioClient.putObject(LOGS_BUCKET, name, circularBuffer.toArray().join('')), 200)
-		}
-	}
-
-  express.get(logsPath, async (req, res) => {
-    if (!hasListner(req.query.u)) {
-      if (!checkPass(req.query.p)) res.end()
-      setListner(req.query.u)
-      return res.send(circularBuffer.toArray().join(''))
-    }
-    setListner(req.query.u)
-    const ls = await readListner(req.query.u)
-    res.send(ls.join(''))
-  })
-  express.post(logsPath, async (req, res) => {
-    if (hasListner(req.query.u)) clearLastLogs(req.query.u)
-    res.end()
-  })
-
-  const StdoutWrite = global.process.stdout.write.bind(global.process.stdout)
-  const StderrWrite = global.process.stderr.write.bind(global.process.stderr)
-
-  global.process.stdout.write = function($str) {
-    if (typeof $str !== 'string') return StdoutWrite($str)
-
-    const strTime = _setTimestamp(moment, $str)
-
-    if ($str[$str.length - 1] === '\n') {
-      const strFormat = _formatLogString(strTime)
-      consoleTimestamp ? StdoutWrite(strFormat) : StdoutWrite($str)
-      broadcast(strFormat)
-      circularBuffer.push(strFormat)
-      writeToFile()
-    } else {
-      consoleTimestamp ? StdoutWrite(strTime) : StdoutWrite($str)
-      broadcast(strTime)
-    }
-  }
-
-  global.process.stderr.write = function($str) {
-    if (typeof $str !== 'string') return StderrWrite($str)
-
-    const strTime = _setTimestamp(moment, $str)
-
-    if ($str[$str.length - 1] === '\n') {
-      const strFormat = _formatLogErrString(strTime)
-      consoleTimestamp ? StderrWrite(strFormat) : StderrWrite($str)
-      broadcast(strFormat)
-      circularBuffer.push(strFormat)
-      writeToFile()
-    } else {
-      consoleTimestamp ? StderrWrite(strTime) : StderrWrite($str)
-      broadcast(strTime)
-    }
+import { createLogBuffer } from './log-buffer.js'
+import { createLogsHandler } from './logs-handler.js'
+
+// guarda em memória as últimas maxLines linhas escritas no stdout/stderr e as disponibiliza
+// na rota logsPath do app express para o cliente (npx console-web-node <servidor>)
+// moment: coloca data e hora em cada linha (sem ele as linhas ficam como foram escritas, ex.: logger que já tem data e hora)
+// consoleTimestamp: escreve também no console as linhas com data e hora (false: o console recebe o texto original)
+export default function ConsoleWebNode({ express, moment, logsPath = '/api/x/logs', maxLines = 10000, consoleTimestamp = true }) {
+  if (!express) throw new Error('console-web-node: informe em express o app onde registrar a rota dos logs')
+
+  const buffer = createLogBuffer(maxLines)
+  express.get(logsPath, createLogsHandler(buffer))
+
+  const format = createFormatter(moment)
+  intercept(process.stdout, buffer, format, consoleTimestamp, (line) => line)
+  intercept(process.stderr, buffer, format, consoleTimestamp, (line) => `\x1b[31m${line}\x1b[0m`)
+}
+
+// só linhas completas (terminadas em \n) vão para os logs; escritas parciais (ex.: progresso com \r) só para o console
+function intercept(stream, buffer, format, consoleTimestamp, color) {
+  const write = stream.write.bind(stream)
+  stream.write = function(chunk, ...args) {
+    if (typeof chunk !== 'string') return write(chunk, ...args)
+    if (!chunk.endsWith('\n')) return write(consoleTimestamp ? format.partial(chunk) : chunk, ...args)
+    const line = color(format.line(chunk))
+    buffer.push(line)
+    return write(consoleTimestamp ? line : chunk, ...args)
   }
 }
 
-const listners = {}
-function broadcast($str) {
-  Object.keys(listners).forEach((key) => {
-    listners[key].logs.push($str)
-  })
-
-  broadcast._timeout && clearTimeout(broadcast._timeout)
-  broadcast._timeout = setTimeout(() => events.emit(BROADCAST_TOKEN), 0)
-}
-
-function setListner(listner) {
-  listners[listner] = listners[listner] || { logs: [], lastLogs: [] }
-
-  listners[listner]._setTimeout && clearTimeout(listners[listner]._setTimeout)
-  listners[listner]._setTimeout = setTimeout(() => {
-    listners[listner]._readTimeout && clearTimeout(listners[listner]._readTimeout)
-    listners[listner]._readClear && events.off(BROADCAST_TOKEN, listners[listner]._readClear)
-    delete listners[listner]
-  }, LISTNER_TIMEOUT)
-}
-
-function clearLastLogs(listner) {
-  listners[listner].lastLogs = []
-}
-
-function readListner(listner) {
-  return new Promise((resolve) => {
-    if (listners[listner].lastLogs[0] || listners[listner].logs[0]) return resolve(read(listner))
-
-    listners[listner]._readTimeout && clearTimeout(listners[listner]._readTimeout)
-    listners[listner]._readClear && events.off(BROADCAST_TOKEN, listners[listner]._readClear)
-
-    listners[listner]._readClear = () => {
-      clearTimeout(listners[listner]._readTimeout)
-      resolve(read(listner))
-    }
-
-    listners[listner]._readTimeout = setTimeout(() => {
-      events.off(BROADCAST_TOKEN, listners[listner]._readClear)
-      resolve([])
-    }, READ_TIMEOUT)
-
-    events.once(BROADCAST_TOKEN, listners[listner]._readClear)
-  })
-}
-
-function read(listner) {
-  listners[listner].lastLogs = listners[listner].lastLogs.concat(listners[listner].logs)
-  listners[listner].logs = []
-  return listners[listner].lastLogs
-}
-
-function hasListner(listner) {
-  return !!listners[listner]
-}
-
-function checkPass(pass) {
-  return crypto.createHash('sha1').update(pass).digest('base64') === 'rJzrVISFf5EOCkdA3DkVpId9yZo='
-}
-
-function _setTimestamp(moment, $str) {
-  return `${moment().format('DD MMM YYYY HH:mm:ss')}   ${$str}`
-}
-
-function _formatLogString($str) {
-  return `${$str.slice(0, -1).replace(/\n/g, '\n                       ') + '\n'}`
-}
-
-function _formatLogErrString($str) {
-  return `\x1b[31m${_formatLogString($str)}\x1b[0m`
+// data e hora no início, com as linhas seguintes de uma mensagem com várias linhas alinhadas depois dela
+export function createFormatter(moment) {
+  if (!moment) return { line: (text) => text, partial: (text) => text }
+  const timestamp = (text) => `${moment().format('DD MMM YYYY HH:mm:ss')}   ${text}`
+  return {
+    line: (text) => timestamp(text).slice(0, -1).replace(/\n/g, '\n                       ') + '\n',
+    partial: timestamp,
+  }
 }

package/src/log-buffer.js

@@ -0,0 +1,52 @@
+import crypto from 'crypto'
+
+// janela com as últimas linhas do log, numeradas em sequência desde o início do processo
+// o cursor (instância.sequência) indica ao cliente de onde continuar a leitura;
+// a instância muda quando o processo reinicia, e aí o cliente recebe a janela inteira do processo novo
+export function createLogBuffer(maxLines) {
+  const instance = crypto.randomBytes(4).toString('hex')
+  const waiting = new Set()
+  let notifying = false
+  let lines = []
+  let total = 0
+
+  const notify = () => {
+    notifying = false
+    const waiters = Array.from(waiting)
+    waiting.clear()
+    waiters.forEach((done) => done())
+  }
+
+  return {
+    push(line) {
+      lines.push(line)
+      total++
+      if (lines.length >= maxLines * 2) lines = lines.slice(-maxLines) // descarta as antigas de uma vez, não a cada linha
+      if (waiting.size && !notifying) { // várias linhas seguidas vão na mesma resposta
+        notifying = true
+        setImmediate(notify)
+      }
+    },
+
+    // linhas depois do cursor (a janela inteira se o cursor for de outra instância, inválido ou ausente) e o próximo cursor
+    since(cursor) {
+      const [cursorInstance, sequence] = String(cursor || '').split('.')
+      const seen = cursorInstance === instance && /^\d+$/.test(sequence) ? Number(sequence) : -Infinity
+      const count = Math.min(total - seen, lines.length, maxLines)
+      return { lines: count > 0 ? lines.slice(-count) : [], cursor: `${instance}.${total}` }
+    },
+
+    // resolve quando chegar uma linha nova ou depois de timeoutMs
+    waitForLines(timeoutMs) {
+      return new Promise((resolve) => {
+        const done = () => {
+          clearTimeout(timer)
+          waiting.delete(done)
+          resolve()
+        }
+        const timer = setTimeout(done, timeoutMs)
+        waiting.add(done)
+      })
+    },
+  }
+}

package/src/logs-handler.js

@@ -0,0 +1,21 @@
+import { isAuthorized as defaultIsAuthorized } from './auth.js'
+
+// GET dos logs: devolve as linhas depois do cursor (?cursor=) e o próximo cursor no cabeçalho X-Cursor
+// sem linhas novas, espera até waitMs por elas (long polling) antes de responder vazio
+export function createLogsHandler(buffer, { waitMs = 30000, isAuthorized = defaultIsAuthorized } = {}) {
+  return async (req, res) => {
+    if (!isAuthorized(req.headers.authorization)) {
+      res.writeHead(401)
+      return res.end()
+    }
+    const cursor = new URL(req.url, 'http://localhost').searchParams.get('cursor')
+    let result = buffer.since(cursor)
+    if (!result.lines.length) {
+      await buffer.waitForLines(waitMs)
+      result = buffer.since(cursor)
+    }
+    if (res.destroyed) return // cliente desconectou enquanto esperava
+    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store', 'X-Cursor': result.cursor })
+    res.end(result.lines.join(''))
+  }
+}

package/src/utils/circular-buffer.js

@@ -1,39 +0,0 @@
-export function CircularBuffer(size) {
-  let currentIndex = size - 1
-  const bufferArray = Array(size)
-  const indexTable = _newBufferNextIndexTable(size)
-  return {
-    push(value) {
-      currentIndex = _push(currentIndex, indexTable, bufferArray, value)
-      return this
-    },
-    toArray() { return _toArray(currentIndex, indexTable, bufferArray) }
-  }
-}
-
-export function _newBufferNextIndexTable(size) {
-  const result = {}
-  for (let index = 0; index < size; index++) {
-    result[index] = index + 1
-  }
-  result[size - 1] = 0
-  return result
-}
-
-export function _push(currentIndex, indexTable, bufferArray, value) {
-  const nextIndex = indexTable[currentIndex]
-  bufferArray[nextIndex] = value
-  return nextIndex
-}
-
-export function _toArray(currentIndex, indexTable, bufferArray) {
-  currentIndex = indexTable[currentIndex]
-  if (typeof bufferArray[currentIndex] === 'undefined') return bufferArray.slice(0, currentIndex)
-
-  const result = []
-  for (const value of bufferArray) {
-    result.push(bufferArray[currentIndex])
-    currentIndex = indexTable[currentIndex]
-  }
-  return result
-}

package/src/utils/circular-buffer.test.js

@@ -1,102 +0,0 @@
-import chai from 'chai'
-import { _newBufferNextIndexTable, _push, _toArray, CircularBuffer } from './circular-buffer.js'
-
-describe(import.meta.url, function() {
-
-  describe(_newBufferNextIndexTable.name, function() {
-    it('deve retornar uma tabela de próximos índices', function() {
-      chai.expect(_newBufferNextIndexTable(4)).to.deep.equal({ 0: 1, 1: 2, 2: 3, 3: 0 })
-    })
-  })
-
-  describe(_push.name, function() {
-    it('deve retornar o array com o valor inserido na posicão 5', function() {
-      const value = 'teste'
-      const index = 3
-      const indexTable = _newBufferNextIndexTable(6)
-      const bufferArray = Array(6)
-      const nextIndex = _push(index, indexTable, bufferArray, value)
-      chai.expect(nextIndex).to.equal(4)
-      chai.expect(bufferArray[4]).to.equal(value)
-    })
-    it('deve retornar o array com o valor inserido na última posição', function() {
-      const value = 'teste'
-      const index = 4
-      const indexTable = _newBufferNextIndexTable(6)
-      const bufferArray = Array(6)
-      const nextIndex = _push(index, indexTable, bufferArray, value)
-      chai.expect(nextIndex).to.equal(5)
-      chai.expect(bufferArray[bufferArray.length - 1]).to.equal(value)
-    })
-    it('deve retornar o array com o valor inserido na primeira posicão', function() {
-      const value = 'teste'
-      const index = 5
-      const indexTable = _newBufferNextIndexTable(6)
-      const bufferArray = Array(6)
-      const nextIndex = _push(index, indexTable, bufferArray, value)
-      chai.expect(nextIndex).to.equal(0)
-      chai.expect(bufferArray[0]).to.equal(value)
-    })
-  })
-
-  describe(_toArray.name, function() {
-    it('deve retornar um array com a órdem dos itens do buffer circular', function() {
-      const bufferArray = [4, 5, 0, 1, 2, 3]
-      const indexTable = _newBufferNextIndexTable(6)
-      const currentIndex = 1
-      const expectedArray = [0, 1, 2, 3, 4, 5]
-      const resultArray = _toArray(currentIndex, indexTable, bufferArray)
-      chai.expect(resultArray).to.deep.equal(expectedArray)
-    })
-    it('deve retornar um array incompleto', function() {
-      const bufferArray = [4, 5, , , , ]
-      const indexTable = _newBufferNextIndexTable(6)
-      const currentIndex = 1
-      const expectedArray = [4, 5]
-      const resultArray = _toArray(currentIndex, indexTable, bufferArray)
-      chai.expect(resultArray).to.deep.equal(expectedArray)
-    })
-  })
-
-  describe(CircularBuffer.name, function() {
-    it('deve retornar um array preenchido 1', function() {
-      const circularBuffer = CircularBuffer(6)
-      const expectedArray = [0, 1, 2, 3, 4, 5]
-      circularBuffer.push(0)
-      circularBuffer.push(1)
-      circularBuffer.push(2)
-      circularBuffer.push(3)
-      circularBuffer.push(4)
-      circularBuffer.push(5)
-      chai.expect(circularBuffer.toArray()).to.deep.equal(expectedArray)
-    })
-    it('deve retornar um array preenchido 2', function() {
-      const circularBuffer = CircularBuffer(6)
-      const expectedArray = [3, 4, 5, 6, 7, 8]
-      circularBuffer.push(0)
-      circularBuffer.push(1)
-      circularBuffer.push(2)
-      circularBuffer.push(3)
-      circularBuffer.push(4)
-      circularBuffer.push(5)
-      circularBuffer.push(6)
-      circularBuffer.push(7)
-      circularBuffer.push(8)
-      chai.expect(circularBuffer.toArray()).to.deep.equal(expectedArray)
-    })
-    it('deve retornar um array preenchido 3', function() {
-      const circularBuffer = CircularBuffer(6)
-      const expectedArray = [6, 7, 8]
-      circularBuffer.push(6)
-      circularBuffer.push(7)
-      circularBuffer.push(8)
-      chai.expect(circularBuffer.toArray()).to.deep.equal(expectedArray)
-    })
-    it('deve retornar um array vazio', function() {
-      const circularBuffer = CircularBuffer(6)
-      const expectedArray = []
-      chai.expect(circularBuffer.toArray()).to.deep.equal(expectedArray)
-    })
-  })
-
-})