@fastify/compress 5.0.0 → 6.1.1

package/.github/workflows/ci.yml

@@ -1,47 +1,18 @@
 name: CI
-'on':
+
+on:
   push:
     paths-ignore:
-      - docs/**
+      - 'docs/**'
       - '*.md'
   pull_request:
     paths-ignore:
-      - docs/**
+      - 'docs/**'
       - '*.md'
+
 jobs:
   test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        node-version:
-          - 10
-          - 12
-          - 14
-          - 16
-          - 17
-        os:
-          - macos-latest
-          - ubuntu-latest
-          - windows-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Use Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: Install Dependencies
-        run: |
-          npm install --ignore-scripts
-      - name: Run Tests
-        run: |
-          npm test
-  automerge:
-    needs: test
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-      contents: write
-    steps:
-      - uses: fastify/github-action-merge-dependabot@v3
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
+    with:
+      license-check: true
+      lint: true

package/README.md

@@ -1,18 +1,17 @@
-# fastify-compress
+# @fastify/compress
 
 ![CI](https://github.com/fastify/fastify-compress/workflows/CI/badge.svg)
-[![NPM version](https://img.shields.io/npm/v/fastify-compress.svg?style=flat)](https://www.npmjs.com/package/fastify-compress)
-[![Known Vulnerabilities](https://snyk.io/test/github/fastify/fastify-compress/badge.svg)](https://snyk.io/test/github/fastify/fastify-compress)
+[![NPM version](https://img.shields.io/npm/v/@fastify/compress.svg?style=flat)](https://www.npmjs.com/package/@fastify/compress)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
 
 Adds compression utils to [the Fastify `reply` object](https://www.fastify.io/docs/latest/Reference/Reply/#reply) and a hook to decompress requests payloads.
 Supports `gzip`, `deflate`, and `brotli`.
 
-> **Important note:** since `fastify-compress` version 4.x payloads that are compressed using the `zip` algorithm are not automatically uncompressed anymore. `fastify-compress` main feature is to provide response compression mechanism to your server, however the `zip` format does not appear in the [IANA maintained Table of Content Encodings](https://www.iana.org/assignments/http-parameters/http-parameters.xml#content-coding) and thus such behavior was out of the scope of this plugin.
+> **Important note:** since `@fastify/compress` version 4.x payloads that are compressed using the `zip` algorithm are not automatically uncompressed anymore. `@fastify/compress` main feature is to provide response compression mechanism to your server, however the `zip` format does not appear in the [IANA maintained Table of Content Encodings](https://www.iana.org/assignments/http-parameters/http-parameters.xml#content-coding) and thus such behavior was out of the scope of this plugin.
 
 ## Install
 ```
-npm i fastify-compress
+npm i @fastify/compress
 ```
 
 ## Usage - Compress replies
@@ -24,7 +23,7 @@ Currently, the following encoding tokens are supported, using the first acceptab
 1. `br`
 2. `gzip`
 3. `deflate`
-4. `*` (no preference — `fastify-compress` will use `gzip`)
+4. `*` (no preference — `@fastify/compress` will use `gzip`)
 5. `identity` (no compression)
 
 If an unsupported encoding is received or if the `'accept-encoding'` header is missing, it will not compress the payload. If an unsupported encoding is received and you would like to return an error, provide an `onUnsupportedEncoding` option.
@@ -34,20 +33,20 @@ The plugin automatically decides if a payload should be compressed based on its
 ### Global hook
 The global compression hook is enabled by default. To disable it, pass the option `{ global: false }`:
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { global: false }
 )
 ```
 Remember that thanks to the Fastify encapsulation model, you can set a global compression, but run it only in a subset of routes if you wrap them inside a plugin.
 
-Important note! If you are using `fastify-compress` plugin together with `fastify-static` plugin, you must register the `fastify-compress` (with *global hook*) **before** registering `fastify-static`.
+Important note! If you are using `@fastify/compress` plugin together with `@fastify/static` plugin, you must register the `@fastify/compress` (with *global hook*) **before** registering `@fastify/static`.
 
 ### Per Route options
 You can specify different options for compression per route by passing in the `compress` options on the route's configuration.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { global: false }
 )
 
@@ -74,21 +73,19 @@ Note that the compress method is configured with either the per route parameters
 the plugin was defined as global.
 
 ```javascript
-const fs = require('fs')
-const fastify = require('fastify')()
+import fs from 'fs'
+import fastify from 'fastify'
 
-fastify.register(require('fastify-compress'), { global: false })
+const app = fastify()
+await app.register(import('@fastify/compress'), { global: false })
 
-fastify.get('/', (req, reply) => {
+app.get('/', (req, reply) => {
   reply
     .type('text/plain')
     .compress(fs.createReadStream('./package.json'))
 })
 
-fastify.listen(3000, function (err) {
-  if (err) throw err
-  console.log(`server listening on ${fastify.server.address().port}`)
-})
+await app.listen({ port: 3000 })
 ```
 
 ## Compress Options
@@ -96,16 +93,16 @@ fastify.listen(3000, function (err) {
 ### threshold
 The minimum byte size for a response to be compressed. Defaults to `1024`.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { threshold: 2048 }
 )
 ```
 ### customTypes
 [mime-db](https://github.com/jshttp/mime-db) is used to determine if a `content-type` should be compressed. You can compress additional content types via regular expression.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { customTypes: /x-protobuf$/ }
 )
 ```
@@ -113,8 +110,8 @@ fastify.register(
 ### onUnsupportedEncoding
 When the encoding is not supported, a custom error response can be sent in place of the uncompressed payload by setting the `onUnsupportedEncoding(encoding, request, reply)` option to be a function that can modify the reply and return a `string | Buffer | Stream | Error` payload.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   {
     onUnsupportedEncoding: (encoding, request, reply) => {
       reply.code(406)
@@ -130,8 +127,8 @@ You can selectively disable response compression by using the `x-no-compression`
 ### Inflate pre-compressed bodies for clients that do not support compression
 Optional feature to inflate pre-compressed data if the client does not include one of the supported compression types in its `accept-encoding` header.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { inflateIfDeflated: true }
 )
 
@@ -143,11 +140,11 @@ fastify.get('/file', (req, reply) =>
 
 ### Customize encoding priority
 
-By default, `fastify-compress` prioritizes compression as described [at the beginning of §Usage - Compress replies](#usage). You can change that by passing an array of compression tokens to the `encodings` option:
+By default, `@fastify/compress` prioritizes compression as described [at the beginning of §Usage - Compress replies](#usage). You can change that by passing an array of compression tokens to the `encodings` option:
 
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   // Only support gzip and deflate, and prefer deflate to gzip
   { encodings: ['deflate', 'gzip'] }
 )
@@ -166,17 +163,17 @@ You can tune compression by setting the `brotliOptions` and `zlibOptions` proper
       },
     },
     zlibOptions: {
-      level: 9, // default is 9, max is 9, min is 0
+      level: 6, // default is typically 6, max is 9, min is 0
     }
   });
 ```
 
 ### Manage `Content-Length` header removal with removeContentLengthHeader
-By default, `fastify-compress` removes the reply `Content-Length` header. You can change that by setting the `removeContentLengthHeader` to `false` either on a global scope or on a route specific scope.
+By default, `@fastify/compress` removes the reply `Content-Length` header. You can change that by setting the `removeContentLengthHeader` to `false` either on a global scope or on a route specific scope.
 
 ```javascript
   // Global plugin scope
-  server.register(fastifyCompress, { global: true, removeContentLengthHeader: false });
+  await server.register(fastifyCompress, { global: true, removeContentLengthHeader: false });
 
   // Route specific scope
   fastify.get('/file', {
@@ -204,8 +201,8 @@ If the request header is missing, the plugin will not do anything and yield to t
 
 The global request decompression hook is enabled by default. To disable it, pass the option `{ global: false }`:
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { global: false }
 )
 ```
@@ -216,8 +213,8 @@ Remember that thanks to the Fastify encapsulation model, you can set a global de
 
 You can specify different options for decompression per route by passing in the `decompress` options on the route's configuration.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { global: false }
 )
 
@@ -238,11 +235,11 @@ fastify.get('/custom-route', {
 
 ### requestEncodings
 
-By default, `fastify-compress` accepts all encodings specified [at the beginning of §Usage - Decompress request payloads](#usage). You can change that by passing an array of compression tokens to the `requestEncodings` option:
+By default, `@fastify/compress` accepts all encodings specified [at the beginning of §Usage - Decompress request payloads](#usage). You can change that by passing an array of compression tokens to the `requestEncodings` option:
 
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   // Only support gzip
   { requestEncodings: ['gzip'] }
 )
@@ -250,19 +247,19 @@ fastify.register(
 
 ### forceRequestEncoding
 
-By default, `fastify-compress` chooses the decompressing algorithm by looking at the `content-encoding` header, if present.
+By default, `@fastify/compress` chooses the decompressing algorithm by looking at the `content-encoding` header, if present.
 
 You can force one algorithm and ignore the header at all by providing the `forceRequestEncoding` option.
 
-Note that if the request payload is not compressed, `fastify-compress` will try to decompress, resulting in an error.
+Note that if the request payload is not compressed, `@fastify/compress` will try to decompress, resulting in an error.
 
 ### onUnsupportedRequestEncoding
 
 When the request payload encoding is not supported, you can customize the response error by setting the `onUnsupportedEncoding(request, encoding)` option to be a function that returns an error.
 
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   {
      onUnsupportedRequestEncoding: (request, encoding) => {
       return {
@@ -281,8 +278,8 @@ fastify.register(
 When the request payload cannot be decompressed using the detected algorithm, you can customize the response error setting the `onInvalidRequestPayload(request, encoding)` option to be a function that returns an error.
 
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   {
     onInvalidRequestPayload: (request, encoding, error) => {
       return {

package/index.js

@@ -8,12 +8,10 @@ const intoStream = require('into-stream')
 const peek = require('peek-stream')
 const Minipass = require('minipass')
 const pumpify = require('pumpify')
-const isGzip = require('is-gzip')
-const isDeflate = require('is-deflate')
-const encodingNegotiator = require('encoding-negotiator')
+const encodingNegotiator = require('@fastify/accept-negotiator')
 const { inherits, format } = require('util')
 
-const { isStream } = require('./lib/utils')
+const { isStream, isGzip, isDeflate } = require('./lib/utils')
 
 const InvalidRequestEncodingError = createError('FST_CP_ERR_INVALID_CONTENT_ENCODING', 'Unsupported Content-Encoding: %s', 415)
 const InvalidRequestCompressedPayloadError = createError('FST_CP_ERR_INVALID_CONTENT', 'Could not decompress the request payload using the provided encoding', 400)
@@ -143,8 +141,8 @@ function processCompressParams (opts) {
 
   params.encodings = Array.isArray(opts.encodings)
     ? supportedEncodings
-        .filter(encoding => opts.encodings.includes(encoding))
-        .sort((a, b) => opts.encodings.indexOf(a) - supportedEncodings.indexOf(b))
+      .filter(encoding => opts.encodings.includes(encoding))
+      .sort((a, b) => opts.encodings.indexOf(a) - supportedEncodings.indexOf(b))
     : supportedEncodings
 
   return params
@@ -175,8 +173,8 @@ function processDecompressParams (opts) {
 
   params.encodings = Array.isArray(opts.requestEncodings)
     ? supportedEncodings
-        .filter(encoding => opts.requestEncodings.includes(encoding))
-        .sort((a, b) => opts.requestEncodings.indexOf(a) - supportedEncodings.indexOf(b))
+      .filter(encoding => opts.requestEncodings.includes(encoding))
+      .sort((a, b) => opts.requestEncodings.indexOf(a) - supportedEncodings.indexOf(b))
     : supportedEncodings
 
   if (opts.forceRequestEncoding) {
@@ -268,8 +266,8 @@ function buildRouteCompress (fastify, params, routeOptions, decorateOnly) {
 
     params.removeContentLengthHeader
       ? reply
-          .header('Content-Encoding', encoding)
-          .removeHeader('content-length')
+        .header('Content-Encoding', encoding)
+        .removeHeader('content-length')
       : reply.header('Content-Encoding', encoding)
 
     stream = zipStream(params.compressStream, encoding)
@@ -393,8 +391,8 @@ function compress (params) {
 
     params.removeContentLengthHeader
       ? this
-          .header('Content-Encoding', encoding)
-          .removeHeader('content-length')
+        .header('Content-Encoding', encoding)
+        .removeHeader('content-length')
       : this.header('Content-Encoding', encoding)
 
     stream = zipStream(params.compressStream, encoding)
@@ -551,6 +549,6 @@ function createError (code, message, statusCode) {
 }
 
 module.exports = fp(compressPlugin, {
-  fastify: '3.x',
-  name: 'fastify-compress'
+  fastify: '4.x',
+  name: '@fastify/compress'
 })

package/lib/utils.js

@@ -1,7 +1,38 @@
 'use strict'
 
+// https://datatracker.ietf.org/doc/html/rfc1950#section-2
+function isDeflate (buffer) {
+  return (
+    typeof buffer === 'object' &&
+    buffer !== null &&
+    buffer.length > 1 &&
+    // CM = 8 denotes the "deflate" compression method
+    (buffer[0] & 0x0f) === 0x08 &&
+    // CINFO Values of above 7 are not allowed by RFC 1950
+    (buffer[0] & 0x80) === 0 &&
+    // The FCHECK value must be such that CMF and FLG, when viewed as
+    // a 16-bit unsigned integer stored in MSB order (CMF*256 + FLG),
+    // is a multiple of 31.
+    (((buffer[0] << 8) + buffer[1]) % 31) === 0
+  )
+}
+
+// https://datatracker.ietf.org/doc/html/rfc1952#page-6
+function isGzip (buffer) {
+  return (
+    typeof buffer === 'object' &&
+    buffer !== null &&
+    buffer.length > 2 &&
+    // ID1
+    buffer[0] === 0x1f &&
+    // ID2
+    buffer[1] === 0x8b &&
+    buffer[2] === 0x08
+  )
+}
+
 function isStream (stream) {
   return stream !== null && typeof stream === 'object' && typeof stream.pipe === 'function'
 }
 
-module.exports = { isStream }
+module.exports = { isGzip, isDeflate, isStream }

package/package.json

@@ -1,34 +1,30 @@
 {
   "name": "@fastify/compress",
-  "version": "5.0.0",
+  "version": "6.1.1",
   "description": "Fastify compression utils",
   "main": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "encoding-negotiator": "^2.0.1",
-    "fastify-plugin": "^3.0.0",
+    "@fastify/accept-negotiator": "^1.0.0",
+    "fastify-plugin": "^4.0.0",
     "into-stream": "^6.0.0",
-    "is-deflate": "^1.0.0",
-    "is-gzip": "^2.0.0",
-    "is-zip": "^1.0.0",
     "mime-db": "^1.51.0",
     "minipass": "^3.1.6",
     "peek-stream": "^1.1.3",
     "pump": "^3.0.0",
-    "pumpify": "^2.0.1",
-    "string-to-stream": "^3.0.1"
+    "pumpify": "^2.0.1"
   },
   "devDependencies": {
-    "@types/node": "^17.0.8",
+    "@fastify/pre-commit": "^2.0.2",
+    "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^5.9.0",
     "@typescript-eslint/parser": "^5.9.0",
     "adm-zip": "^0.5.9",
-    "fastify": "^3.25.3",
+    "fastify": "^4.0.0-rc.2",
     "jsonstream": "^1.0.3",
-    "pre-commit": "^1.2.2",
-    "standard": "^16.0.4",
+    "standard": "^17.0.0",
     "tap": "^16.0.0",
-    "tsd": "^0.20.0",
+    "tsd": "^0.22.0",
     "typescript": "^4.5.4"
   },
   "scripts": {
@@ -61,9 +57,6 @@
     "type": "git",
     "url": "git+https://github.com/fastify/fastify-compress.git"
   },
-  "engines": {
-    "node": ">=10.16"
-  },
   "tsd": {
     "directory": "test/types"
   },

package/test/global-compress.test.js

@@ -8,6 +8,7 @@ const AdmZip = require('adm-zip')
 const JSONStream = require('jsonstream')
 const Fastify = require('fastify')
 const compressPlugin = require('../index')
+const { once } = require('events')
 
 test('When `global` is not set, it is `true` by default :', async (t) => {
   t.test('it should compress Buffer data using brotli when `Accept-Encoding` request header is `br`', async (t) => {
@@ -343,7 +344,7 @@ test('It should send compressed Buffer data when `global` is `true` :', async (t
     t.plan(1)
 
     const fastify = Fastify()
-    fastify.register(compressPlugin, { global: true, threshold: 0 })
+    await fastify.register(compressPlugin, { global: true, threshold: 0 })
 
     const buf = Buffer.from('hello world')
     fastify.get('/', (request, reply) => {
@@ -1639,14 +1640,16 @@ test('It should return a serialized payload when `inflateIfDeflated` is `true` a
   t.equal(two.payload, compressedBufferPayload.toString())
 })
 
-test('It should close the stream', (t) => {
-  t.plan(4)
+test('It should close the stream', async (t) => {
+  t.plan(3)
 
   const fastify = Fastify()
-  fastify.register(compressPlugin, { global: true })
+  await fastify.register(compressPlugin, { global: true })
+
+  const stream = createReadStream('./package.json')
+  const closed = once(stream, 'close')
 
   fastify.get('/', (request, reply) => {
-    const stream = createReadStream('./package.json')
     stream.on('close', () => t.ok('stream closed'))
 
     reply
@@ -1654,16 +1657,15 @@ test('It should close the stream', (t) => {
       .compress(stream)
   })
 
-  fastify.inject({
+  const response = await fastify.inject({
     url: '/',
     method: 'GET'
-  }, (err, response) => {
-    t.error(err)
-
-    const file = readFileSync('./package.json', 'utf8')
-    t.equal(response.statusCode, 200)
-    t.equal(file, response.payload)
   })
+
+  const file = readFileSync('./package.json', 'utf8')
+  t.equal(response.statusCode, 200)
+  t.equal(file, response.payload)
+  await closed
 })
 
 test('It should log an existing error with stream onEnd handler', async (t) => {

package/test/routes-compress.test.js

@@ -225,27 +225,20 @@ test('When using routes `compress` settings :', async (t) => {
   })
 
   t.test('it should throw an error on invalid route `compress` settings', async (t) => {
-    t.plan(2)
+    t.plan(1)
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: false })
 
-    fastify.get('/', {
-      compress: 'bad config'
-    }, (request, reply) => {
-      reply.send('')
-    })
-
-    await fastify.inject({
-      url: '/',
-      method: 'GET',
-      headers: {
-        'accept-encoding': 'gzip'
-      }
-    }).catch((err) => {
-      t.type(err, Error)
+    try {
+      fastify.get('/', {
+        compress: 'bad config'
+      }, (request, reply) => {
+        reply.send('')
+      })
+    } catch (err) {
       t.equal(err.message, 'Unknown value for route compress configuration')
-    })
+    }
   })
 })
 
@@ -385,32 +378,25 @@ test('When using the old routes `{ config: compress }` option :', async (t) => {
   })
 
   t.test('it should use the old routes `{ config: compress }` options over routes `compress` options', async (t) => {
-    t.plan(2)
+    t.plan(1)
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: false })
 
-    fastify.get('/', {
-      compress: {
-        zlib: { createGzip: () => zlib.createGzip() }
-      },
-      config: {
-        compress: 'bad config'
-      }
-    }, (request, reply) => {
-      reply.send('')
-    })
-
-    await fastify.inject({
-      url: '/',
-      method: 'GET',
-      headers: {
-        'accept-encoding': 'gzip'
-      }
-    }).catch((err) => {
-      t.type(err, Error)
+    try {
+      fastify.get('/', {
+        compress: {
+          zlib: { createGzip: () => zlib.createGzip() }
+        },
+        config: {
+          compress: 'bad config'
+        }
+      }, (request, reply) => {
+        reply.send('')
+      })
+    } catch (err) {
       t.equal(err.message, 'Unknown value for route compress configuration')
-    })
+    }
   })
 })
 

package/test/routes-decompress.test.js

@@ -189,26 +189,18 @@ test('When using routes `decompress` settings :', async (t) => {
   })
 
   t.test('it should throw an error on invalid route `decompress` settings', async (t) => {
-    t.plan(2)
+    t.plan(1)
 
     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)
+    try {
+      fastify.post('/', { decompress: 'bad config' }, (request, reply) => {
+        reply.send(request.body.name)
+      })
+    } catch (err) {
       t.equal(err.message, 'Unknown value for route decompress configuration')
-    })
+    }
   })
 })
 
@@ -274,32 +266,24 @@ test('When using the old routes `{ config: decompress }` option :', async (t) =>
   })
 
   t.test('it should use the old routes `{ config: decompress }` options over routes `decompress` options', async (t) => {
-    t.plan(2)
+    t.plan(1)
 
     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)
+    try {
+      fastify.post('/', {
+        decompress: {
+          zlib: { createGunzip: () => zlib.createGunzip() }
+        },
+        config: {
+          decompress: 'bad config'
+        }
+      }, (request, reply) => {
+        reply.send(request.body.name)
+      })
+    } catch (err) {
       t.equal(err.message, 'Unknown value for route decompress configuration')
-    })
+    }
   })
 })

package/test/utils.test.js

@@ -4,7 +4,7 @@ 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')
+const { isStream, isDeflate, isGzip } = require('../lib/utils')
 
 test('isStream() utility should be able to detect Streams', async (t) => {
   t.plan(12)
@@ -25,3 +25,39 @@ test('isStream() utility should be able to detect Streams', async (t) => {
   t.equal(isStream(undefined), false)
   t.equal(isStream(''), false)
 })
+
+test('isDeflate() utility should be able to detect deflate compressed Buffer', async (t) => {
+  t.plan(14)
+
+  t.equal(isDeflate(Buffer.alloc(0)), false)
+  t.equal(isDeflate(Buffer.alloc(0)), false)
+  t.equal(isDeflate(Buffer.from([0x78])), false)
+  t.equal(isDeflate(Buffer.from([0x78, 0x00])), false)
+  t.equal(isDeflate(Buffer.from([0x7a, 0x01])), false)
+  t.equal(isDeflate(Buffer.from([0x88, 0x01])), false)
+  t.equal(isDeflate(Buffer.from([0x78, 0x11])), false)
+  t.equal(isDeflate(Buffer.from([0x78, 0x01])), true)
+  t.equal(isDeflate(Buffer.from([0x78, 0x9c])), true)
+  t.equal(isDeflate(Buffer.from([0x78, 0xda])), true)
+
+  t.equal(isDeflate({}), false)
+  t.equal(isDeflate(null), false)
+  t.equal(isDeflate(undefined), false)
+  t.equal(isDeflate(''), false)
+})
+
+test('isGzip() utility should be able to detect gzip compressed Buffer', async (t) => {
+  t.plan(10)
+
+  t.equal(isGzip(Buffer.alloc(0)), false)
+  t.equal(isGzip(Buffer.alloc(1)), false)
+  t.equal(isGzip(Buffer.alloc(2)), false)
+  t.equal(isGzip(Buffer.from([0x1f, 0x8b])), false)
+  t.equal(isGzip(Buffer.from([0x1f, 0x8b, 0x00])), false)
+  t.equal(isGzip(Buffer.from([0x1f, 0x8b, 0x08])), true)
+
+  t.equal(isGzip({}), false)
+  t.equal(isGzip(null), false)
+  t.equal(isGzip(undefined), false)
+  t.equal(isGzip(''), false)
+})