@fastify/compress 5.0.0

package/test/routes-decompress.test.js

@@ -0,0 +1,305 @@
+'use strict'
+
+const { test } = require('tap')
+const { createReadStream } = require('fs')
+const path = require('path')
+const zlib = require('zlib')
+const pump = require('pump')
+const Fastify = require('fastify')
+const compressPlugin = require('../index')
+
+function createPayload (compressor) {
+  let payload = createReadStream(path.resolve(__dirname, '../package.json'))
+
+  if (compressor) {
+    payload = pump(payload, compressor())
+  }
+
+  return payload
+}
+
+test('When using routes `decompress` settings :', async (t) => {
+  t.test('it should decompress data using the route custom provided `createInflate` method', async (t) => {
+    t.plan(8)
+
+    let usedCustomGlobal = false
+    let usedCustom = false
+    const customZlibGlobal = { createInflate: () => (usedCustomGlobal = true) && zlib.createInflate() }
+    const customZlib = { createInflate: () => (usedCustom = true) && zlib.createInflate() }
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { zlib: customZlibGlobal })
+
+    fastify.post('/', (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    fastify.post('/custom', {
+      decompress: {
+        zlib: customZlib
+      }
+    }, (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    await fastify.inject({
+      url: '/',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'deflate'
+      },
+      payload: createPayload(zlib.createDeflate)
+    }).then((response) => {
+      t.equal(usedCustom, false)
+      t.equal(usedCustomGlobal, true)
+
+      t.equal(response.statusCode, 200)
+      t.equal(response.body, '@fastify/compress')
+
+      usedCustom = false
+      usedCustomGlobal = false
+    })
+    const response = await fastify.inject({
+      url: '/custom',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'deflate'
+      },
+      payload: createPayload(zlib.createDeflate)
+    })
+    t.equal(usedCustom, true)
+    t.equal(usedCustomGlobal, false)
+
+    t.equal(response.statusCode, 200)
+    t.equal(response.body, '@fastify/compress')
+  })
+
+  t.test('it should decompress data using the route custom provided `createGunzip` method', async (t) => {
+    t.plan(8)
+
+    let usedCustomGlobal = false
+    let usedCustom = false
+    const customZlibGlobal = { createGunzip: () => (usedCustomGlobal = true) && zlib.createGunzip() }
+    const customZlib = { createGunzip: () => (usedCustom = true) && zlib.createGunzip() }
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { zlib: customZlibGlobal })
+
+    fastify.post('/', (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    fastify.post('/custom', {
+      decompress: {
+        zlib: customZlib
+      }
+    }, (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    await fastify.inject({
+      url: '/',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'gzip'
+      },
+      payload: createPayload(zlib.createGzip)
+    }).then((response) => {
+      t.equal(usedCustom, false)
+      t.equal(usedCustomGlobal, true)
+
+      t.equal(response.statusCode, 200)
+      t.equal(response.body, '@fastify/compress')
+
+      usedCustom = false
+      usedCustomGlobal = false
+    })
+
+    const response = await fastify.inject({
+      url: '/custom',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'gzip'
+      },
+      payload: createPayload(zlib.createGzip)
+    })
+    t.equal(usedCustom, true)
+    t.equal(usedCustomGlobal, false)
+
+    t.equal(response.statusCode, 200)
+    t.equal(response.body, '@fastify/compress')
+  })
+
+  t.test('it should not decompress data when route `decompress` option is set to `false`', async (t) => {
+    t.plan(6)
+
+    let usedCustomGlobal = false
+    const customZlibGlobal = { createGunzip: () => (usedCustomGlobal = true) && zlib.createGunzip() }
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { zlib: customZlibGlobal })
+
+    fastify.post('/', (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    fastify.post('/custom', { decompress: false }, (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    await fastify.inject({
+      url: '/',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'gzip'
+      },
+      payload: createPayload(zlib.createGzip)
+    }).then((response) => {
+      t.equal(usedCustomGlobal, true)
+
+      t.equal(response.statusCode, 200)
+      t.equal(response.body, '@fastify/compress')
+
+      usedCustomGlobal = false
+    })
+
+    const response = await fastify.inject({
+      url: '/custom',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'gzip'
+      },
+      payload: createPayload(zlib.createGzip)
+    })
+    t.equal(usedCustomGlobal, false)
+
+    t.equal(response.statusCode, 400)
+    t.strictSame(response.json(), {
+      statusCode: 400,
+      code: 'FST_ERR_CTP_INVALID_CONTENT_LENGTH',
+      error: 'Bad Request',
+      message: 'Request body size did not match Content-Length'
+    })
+  })
+
+  t.test('it should throw an error on invalid route `decompress` settings', async (t) => {
+    t.plan(2)
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { global: false })
+
+    fastify.post('/', { decompress: 'bad config' }, (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    await fastify.inject({
+      url: '/',
+      method: 'POST',
+      headers: {
+        'content-encoding': 'gzip'
+      },
+      payload: ''
+    }).catch((err) => {
+      t.type(err, Error)
+      t.equal(err.message, 'Unknown value for route decompress configuration')
+    })
+  })
+})
+
+test('When using the old routes `{ config: decompress }` option :', async (t) => {
+  t.test('it should decompress data using the route custom provided `createGunzip` method', async (t) => {
+    t.plan(8)
+
+    let usedCustomGlobal = false
+    let usedCustom = false
+    const customZlibGlobal = { createGunzip: () => (usedCustomGlobal = true) && zlib.createGunzip() }
+    const customZlib = { createGunzip: () => (usedCustom = true) && zlib.createGunzip() }
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { zlib: customZlibGlobal })
+
+    fastify.post('/', (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    fastify.post('/custom', {
+      config: {
+        decompress: {
+          zlib: customZlib
+        }
+      }
+    }, (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    await fastify.inject({
+      url: '/',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'gzip'
+      },
+      payload: createPayload(zlib.createGzip)
+    }).then((response) => {
+      t.equal(usedCustom, false)
+      t.equal(usedCustomGlobal, true)
+
+      t.equal(response.statusCode, 200)
+      t.equal(response.body, '@fastify/compress')
+
+      usedCustom = false
+      usedCustomGlobal = false
+    })
+
+    const response = await fastify.inject({
+      url: '/custom',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'gzip'
+      },
+      payload: createPayload(zlib.createGzip)
+    })
+    t.equal(usedCustom, true)
+    t.equal(usedCustomGlobal, false)
+
+    t.equal(response.statusCode, 200)
+    t.equal(response.body, '@fastify/compress')
+  })
+
+  t.test('it should use the old routes `{ config: decompress }` options over routes `decompress` options', async (t) => {
+    t.plan(2)
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { global: false })
+
+    fastify.post('/', {
+      decompress: {
+        zlib: { createGunzip: () => zlib.createGunzip() }
+      },
+      config: {
+        decompress: 'bad config'
+      }
+    }, (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    await fastify.inject({
+      url: '/',
+      method: 'POST',
+      headers: {
+        'content-encoding': 'gzip'
+      },
+      payload: ''
+    }).catch((err) => {
+      t.type(err, Error)
+      t.equal(err.message, 'Unknown value for route decompress configuration')
+    })
+  })
+})

package/test/types/index.test-d.ts

@@ -0,0 +1,115 @@
+import fastify, { FastifyInstance } from 'fastify'
+import { createReadStream } from 'fs'
+import { expectError, expectType } from 'tsd'
+import * as zlib from 'zlib'
+import fastifyCompress, { FastifyCompressOptions } from '../..'
+
+const stream = createReadStream('./package.json')
+
+const withGlobalOptions: FastifyCompressOptions = {
+  global: true,
+  threshold: 10,
+  zlib: zlib,
+  brotliOptions: {
+    params: {
+      [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
+      [zlib.constants.BROTLI_PARAM_QUALITY]: 4
+    }
+  },
+  zlibOptions: { level: 1 },
+  inflateIfDeflated: true,
+  customTypes: /x-protobuf$/,
+  encodings: ['gzip', 'br', 'identity', 'deflate'],
+  requestEncodings: ['gzip', 'br', 'identity', 'deflate'],
+  forceRequestEncoding: 'gzip',
+  removeContentLengthHeader: true
+}
+
+const app: FastifyInstance = fastify()
+app.register(fastifyCompress, withGlobalOptions)
+
+app.get('/test-one', async (request, reply) => {
+  expectType<void>(reply.compress(stream))
+})
+
+app.get('/test-two', async (request, reply) => {
+  expectError(reply.compress())
+})
+
+// Instanciation of an app without global
+const appWithoutGlobal: FastifyInstance = fastify()
+appWithoutGlobal.register(fastifyCompress, { global: false })
+
+appWithoutGlobal.get('/one', {
+  compress: {
+    zlib: {
+      createGzip: () => zlib.createGzip()
+    },
+    removeContentLengthHeader: false
+  },
+  decompress: {
+    forceRequestEncoding: 'gzip',
+    zlib: {
+      createGunzip: () => zlib.createGunzip()
+    }
+  }
+}, (request, reply) => {
+  expectType<void>(reply.type('text/plain').compress(stream))
+})
+
+appWithoutGlobal.get('/two', {
+  config: {
+    compress: {
+      zlib: {
+        createGzip: () => zlib.createGzip()
+      }
+    },
+    decompress: {
+      forceRequestEncoding: 'gzip',
+      zlib: {
+        createGunzip: () => zlib.createGunzip()
+      }
+    }
+  }
+}, (request, reply) => {
+  expectType<void>(reply.type('text/plain').compress(stream))
+})
+
+expectError(
+  appWithoutGlobal.get('/throw-a-ts-arg-error-on-shorthand-route', {
+    compress: 'bad compress route option value',
+    decompress: 'bad decompress route option value'
+  }, (request, reply) => {
+    expectType<void>(reply.type('text/plain').compress(stream))
+  })
+)
+
+expectError(
+  appWithoutGlobal.route({
+    method: 'GET',
+    path: '/throw-a-ts-arg-error',
+    compress: 'bad compress route option value',
+    decompress: 'bad decompress route option value',
+    handler: (request, reply) => { expectType<void>(reply.type('text/plain').compress(stream)) }
+  })
+)
+
+appWithoutGlobal.inject(
+  {
+    method: 'GET',
+    path: '/throw-a-ts-arg-error',
+    headers: {
+      'accept-encoding': 'gzip'
+    }
+  },
+  (err) => {
+    expectType<Error>(err)
+  }
+)
+
+// Instanciation of an app that should trigger a typescript error
+const appThatTriggerAnError = fastify()
+expectError(appThatTriggerAnError.register(fastifyCompress, {
+  global: true,
+  thisOptionDoesNotExist: 'trigger a typescript error'
+}))

package/test/utils.test.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { createReadStream } = require('fs')
+const { Socket } = require('net')
+const { Duplex, PassThrough, Readable, Stream, Transform, Writable } = require('stream')
+const { test } = require('tap')
+const { isStream } = require('../lib/utils')
+
+test('isStream() utility should be able to detect Streams', async (t) => {
+  t.plan(12)
+
+  t.equal(isStream(new Stream()), true)
+  t.equal(isStream(new Readable()), true)
+  t.equal(isStream(new Writable()), true)
+  t.equal(isStream(new Duplex()), true)
+  t.equal(isStream(new Transform()), true)
+  t.equal(isStream(new PassThrough()), true)
+
+  t.equal(isStream(createReadStream('package.json')), true)
+
+  t.equal(isStream(new Socket()), true)
+
+  t.equal(isStream({}), false)
+  t.equal(isStream(null), false)
+  t.equal(isStream(undefined), false)
+  t.equal(isStream(''), false)
+})